From 088cc9c5882cafc15aca90c834e15795c6ae65ea Mon Sep 17 00:00:00 2001 From: luoliangyi <87842688@qq.com> Date: Wed, 11 May 2022 18:55:56 +0800 Subject: [PATCH] =?UTF-8?q?=E7=BC=96=E8=AF=91aarch64=E7=89=88=E6=9C=AC?= =?UTF-8?q?=E7=9A=84libcurl?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../libcurl/uos/aarch64/include/curl/curl.h | 3090 +++++++++++++++++ .../uos/aarch64/include/curl/curlver.h | 77 + .../libcurl/uos/aarch64/include/curl/easy.h | 123 + .../uos/aarch64/include/curl/mprintf.h | 50 + .../libcurl/uos/aarch64/include/curl/multi.h | 457 +++ .../uos/aarch64/include/curl/options.h | 68 + .../uos/aarch64/include/curl/stdcheaders.h | 33 + .../libcurl/uos/aarch64/include/curl/system.h | 488 +++ .../uos/aarch64/include/curl/typecheck-gcc.h | 707 ++++ .../libcurl/uos/aarch64/include/curl/urlapi.h | 145 + third_party/libcurl/uos/aarch64/lib/libcurl.a | Bin 0 -> 941078 bytes .../libcurl/uos/aarch64/lib/libcurl.la | 41 + .../uos/aarch64/lib/pkgconfig/libcurl.pc | 39 + 13 files changed, 5318 insertions(+) create mode 100644 third_party/libcurl/uos/aarch64/include/curl/curl.h create mode 100644 third_party/libcurl/uos/aarch64/include/curl/curlver.h create mode 100644 third_party/libcurl/uos/aarch64/include/curl/easy.h create mode 100644 third_party/libcurl/uos/aarch64/include/curl/mprintf.h create mode 100644 third_party/libcurl/uos/aarch64/include/curl/multi.h create mode 100644 third_party/libcurl/uos/aarch64/include/curl/options.h create mode 100644 third_party/libcurl/uos/aarch64/include/curl/stdcheaders.h create mode 100644 third_party/libcurl/uos/aarch64/include/curl/system.h create mode 100644 third_party/libcurl/uos/aarch64/include/curl/typecheck-gcc.h create mode 100644 third_party/libcurl/uos/aarch64/include/curl/urlapi.h create mode 100644 third_party/libcurl/uos/aarch64/lib/libcurl.a create mode 100755 third_party/libcurl/uos/aarch64/lib/libcurl.la create mode 100644 third_party/libcurl/uos/aarch64/lib/pkgconfig/libcurl.pc diff --git a/third_party/libcurl/uos/aarch64/include/curl/curl.h b/third_party/libcurl/uos/aarch64/include/curl/curl.h new file mode 100644 index 00000000..2e260d51 --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/curl.h @@ -0,0 +1,3090 @@ +#ifndef CURLINC_CURL_H +#define CURLINC_CURL_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2022, 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 https://curl.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: + * https://curl.se/libcurl/ + */ + +#ifdef CURL_NO_OLDIES +#define CURL_STRICTER +#endif + +#include "curlver.h" /* libcurl version defines */ +#include "system.h" /* determine things run-time */ + +/* + * Define CURL_WIN32 when build target is Win32 API + */ + +#if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && \ + !defined(__SYMBIAN32__) +#define CURL_WIN32 +#endif + +#include +#include + +#if (defined(__FreeBSD__) && (__FreeBSD__ >= 2)) || defined(__MidnightBSD__) +/* Needed for __FreeBSD_version or __MidnightBSD_version symbol definition */ +#include +#endif + +/* The include stuff here below is mainly for time_t! */ +#include +#include + +#if defined(CURL_WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__) +#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || \ + defined(__LWIP_OPT_H__) || defined(LWIP_HDR_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(__ANDROID__) || defined(__OpenBSD__) || \ + defined(__CYGWIN__) || defined(AMIGA) || defined(__NuttX__) || \ + (defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) || \ + (defined(__MidnightBSD_version) && (__MidnightBSD_version < 100000)) +#include +#endif + +#if !defined(CURL_WIN32) && !defined(_WIN32_WCE) +#include +#endif + +#if !defined(CURL_WIN32) +#include +#endif + +/* Compatibility for non-Clang compilers */ +#ifndef __has_declspec_attribute +# define __has_declspec_attribute(x) 0 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) +typedef struct Curl_easy CURL; +typedef struct Curl_share CURLSH; +#else +typedef void CURL; +typedef void CURLSH; +#endif + +/* + * libcurl external API function linkage decorations. + */ + +#ifdef CURL_STATICLIB +# define CURL_EXTERN +#elif defined(CURL_WIN32) || defined(__SYMBIAN32__) || \ + (__has_declspec_attribute(dllexport) && \ + __has_declspec_attribute(dllimport)) +# if defined(BUILDING_LIBCURL) +# define CURL_EXTERN __declspec(dllexport) +# else +# define CURL_EXTERN __declspec(dllimport) +# endif +#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS) +# define CURL_EXTERN CURL_EXTERN_SYMBOL +#else +# define CURL_EXTERN +#endif + +#ifndef curl_socket_typedef +/* socket typedef */ +#if defined(CURL_WIN32) && !defined(__LWIP_OPT_H__) && !defined(LWIP_HDR_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 */ + +/* enum for the different supported SSL backends */ +typedef enum { + CURLSSLBACKEND_NONE = 0, + CURLSSLBACKEND_OPENSSL = 1, + CURLSSLBACKEND_GNUTLS = 2, + CURLSSLBACKEND_NSS = 3, + CURLSSLBACKEND_OBSOLETE4 = 4, /* Was QSOSSL. */ + CURLSSLBACKEND_GSKIT = 5, + CURLSSLBACKEND_POLARSSL = 6, + CURLSSLBACKEND_WOLFSSL = 7, + CURLSSLBACKEND_SCHANNEL = 8, + CURLSSLBACKEND_SECURETRANSPORT = 9, + CURLSSLBACKEND_AXTLS = 10, /* never used since 7.63.0 */ + CURLSSLBACKEND_MBEDTLS = 11, + CURLSSLBACKEND_MESALINK = 12, + CURLSSLBACKEND_BEARSSL = 13, + CURLSSLBACKEND_RUSTLS = 14 +} curl_sslbackend; + +/* aliases for library clones and renames */ +#define CURLSSLBACKEND_LIBRESSL CURLSSLBACKEND_OPENSSL +#define CURLSSLBACKEND_BORINGSSL CURLSSLBACKEND_OPENSSL + +/* deprecated names: */ +#define CURLSSLBACKEND_CYASSL CURLSSLBACKEND_WOLFSSL +#define CURLSSLBACKEND_DARWINSSL CURLSSLBACKEND_SECURETRANSPORT + +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, see also + CURL_HTTPPOST_LARGE */ + 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 */ + +/* specified content is a file name */ +#define CURL_HTTPPOST_FILENAME (1<<0) +/* specified content is a file name */ +#define CURL_HTTPPOST_READFILE (1<<1) +/* name is only stored pointer do not free in formfree */ +#define CURL_HTTPPOST_PTRNAME (1<<2) +/* contents is only stored pointer do not free in formfree */ +#define CURL_HTTPPOST_PTRCONTENTS (1<<3) +/* upload file from buffer */ +#define CURL_HTTPPOST_BUFFER (1<<4) +/* upload file from pointer contents */ +#define CURL_HTTPPOST_PTRBUFFER (1<<5) +/* upload file contents by using the regular read callback to get the data and + pass the given pointer as custom pointer */ +#define CURL_HTTPPOST_CALLBACK (1<<6) +/* use size in 'contentlen', added in 7.46.0 */ +#define CURL_HTTPPOST_LARGE (1<<7) + + 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 */ + curl_off_t contentlen; /* alternative length of contents + field. Used if CURL_HTTPPOST_LARGE is + set. Added in 7.46.0 */ +}; + + +/* This is a return code for the progress callback that, when returned, will + signal libcurl to continue executing the default progress function */ +#define CURL_PROGRESSFUNC_CONTINUE 0x10000001 + +/* This is the CURLOPT_PROGRESSFUNCTION callback prototype. It is now + considered deprecated but was the only choice up until 7.31.0 */ +typedef int (*curl_progress_callback)(void *clientp, + double dltotal, + double dlnow, + double ultotal, + double ulnow); + +/* This is the CURLOPT_XFERINFOFUNCTION callback prototype. It was introduced + in 7.32.0, avoids the use of floating point numbers and provides more + detailed information. */ +typedef int (*curl_xferinfo_callback)(void *clientp, + curl_off_t dltotal, + curl_off_t dlnow, + curl_off_t ultotal, + curl_off_t ulnow); + +#ifndef CURL_MAX_READ_SIZE + /* The maximum receive buffer size configurable via CURLOPT_BUFFERSIZE. */ +#define CURL_MAX_READ_SIZE 524288 +#endif + +#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); + +/* This callback will be called when a new resolver request is made */ +typedef int (*curl_resolver_start_callback)(void *resolver_state, + void *reserved, void *userdata); + +/* 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) + +/* Information about a single file, used when doing FTP wildcard matching */ +struct curl_fileinfo { + char *filename; + curlfiletype filetype; + time_t time; /* always zero! */ + 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 + +/* Return code for when the trailing headers' callback has terminated + without any errors*/ +#define CURL_TRAILERFUNC_OK 0 +/* Return code for when was an error in the trailing header's list and we + want to abort the request */ +#define CURL_TRAILERFUNC_ABORT 1 + +typedef size_t (*curl_read_callback)(char *buffer, + size_t size, + size_t nitems, + void *instream); + +typedef int (*curl_trailer_callback)(struct curl_slist **list, + void *userdata); + +typedef enum { + CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ + CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */ + 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); + +#ifndef CURL_DID_MEMORY_FUNC_TYPEDEFS +/* + * 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); + +#define CURL_DID_MEMORY_FUNC_TYPEDEFS +#endif + +/* 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 */ + +/* This is the CURLOPT_PREREQFUNCTION callback prototype. */ +typedef int (*curl_prereq_callback)(void *clientp, + char *conn_primary_ip, + char *conn_local_ip, + int conn_primary_port, + int conn_local_port); + +/* Return code for when the pre-request callback has terminated without + any errors */ +#define CURL_PREREQFUNC_OK 0 +/* Return code for when the pre-request callback wants to abort the + request */ +#define CURL_PREREQFUNC_ABORT 1 + +/* 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_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_FTP_ACCEPT_FAILED, /* 10 - [was obsoleted in April 2006 for + 7.15.4, reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */ + CURLE_FTP_ACCEPT_TIMEOUT, /* 12 - timeout occurred accepting server + [was obsoleted in August 2007 for 7.17.0, + reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */ + CURLE_FTP_WEIRD_227_FORMAT, /* 14 */ + CURLE_FTP_CANT_GET_HOST, /* 15 */ + CURLE_HTTP2, /* 16 - A problem in the http2 framing layer. + [was obsoleted in August 2007 for 7.17.0, + reused in July 2014 for 7.38.0] */ + 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 */ + 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 - NOT USED starting with 7.53.0 */ + 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_SETOPT_OPTION_SYNTAX, /* 49 - Malformed setopt option */ + CURLE_OBSOLETE50, /* 50 - NOT USED */ + CURLE_OBSOLETE51, /* 51 - NOT USED */ + 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_PEER_FAILED_VERIFICATION, /* 60 - peer's certificate or fingerprint + wasn't verified fine */ + CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */ + CURLE_OBSOLETE62, /* 62 - NOT IN USE since 7.82.0 */ + 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_OBSOLETE76, /* 76 - NOT IN USE since 7.82.0 */ + 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 */ + CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the + session will be queued */ + CURLE_SSL_PINNEDPUBKEYNOTMATCH, /* 90 - specified pinned public key did not + match */ + CURLE_SSL_INVALIDCERTSTATUS, /* 91 - invalid certificate status */ + CURLE_HTTP2_STREAM, /* 92 - stream error in HTTP/2 framing layer + */ + CURLE_RECURSIVE_API_CALL, /* 93 - an api function was called from + inside a callback */ + CURLE_AUTH_ERROR, /* 94 - an authentication function returned an + error */ + CURLE_HTTP3, /* 95 - An HTTP/3 layer problem */ + CURLE_QUIC_CONNECT_ERROR, /* 96 - QUIC connection error */ + CURLE_PROXY, /* 97 - proxy handshake error */ + CURLE_SSL_CLIENTCERT, /* 98 - client-side certificate required */ + CURL_LAST /* never use! */ +} CURLcode; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Previously obsolete error code re-used in 7.38.0 */ +#define CURLE_OBSOLETE16 CURLE_HTTP2 + +/* Previously obsolete error codes re-used in 7.24.0 */ +#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED +#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT + +/* compatibility with older names */ +#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING +#define CURLE_FTP_WEIRD_SERVER_REPLY CURLE_WEIRD_SERVER_REPLY + +/* The following were added in 7.62.0 */ +#define CURLE_SSL_CACERT CURLE_PEER_FAILED_VERIFICATION + +/* The following were added in 7.21.5, April 2011 */ +#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION + +/* Added for 7.78.0 */ +#define CURLE_TELNET_OPTION_SYNTAX CURLE_SETOPT_OPTION_SYNTAX + +/* 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 +#define CURLE_LDAP_INVALID_URL CURLE_OBSOLETE62 +#define CURLE_CONV_REQD CURLE_OBSOLETE76 + +/* 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 + +/* Provide defines for really old option names */ +#define CURLOPT_FILE CURLOPT_WRITEDATA /* name changed in 7.9.7 */ +#define CURLOPT_INFILE CURLOPT_READDATA /* name changed in 7.9.7 */ +#define CURLOPT_WRITEHEADER CURLOPT_HEADERDATA + +/* Since long deprecated options with no code in the lib that does anything + with them. */ +#define CURLOPT_WRITEINFO CURLOPT_OBSOLETE40 +#define CURLOPT_CLOSEPOLICY CURLOPT_OBSOLETE72 + +#endif /*!CURL_NO_OLDIES*/ + +/* + * Proxy error codes. Returned in CURLINFO_PROXY_ERROR if CURLE_PROXY was + * return for the transfers. + */ +typedef enum { + CURLPX_OK, + CURLPX_BAD_ADDRESS_TYPE, + CURLPX_BAD_VERSION, + CURLPX_CLOSED, + CURLPX_GSSAPI, + CURLPX_GSSAPI_PERMSG, + CURLPX_GSSAPI_PROTECTION, + CURLPX_IDENTD, + CURLPX_IDENTD_DIFFER, + CURLPX_LONG_HOSTNAME, + CURLPX_LONG_PASSWD, + CURLPX_LONG_USER, + CURLPX_NO_AUTH, + CURLPX_RECV_ADDRESS, + CURLPX_RECV_AUTH, + CURLPX_RECV_CONNECT, + CURLPX_RECV_REQACK, + CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED, + CURLPX_REPLY_COMMAND_NOT_SUPPORTED, + CURLPX_REPLY_CONNECTION_REFUSED, + CURLPX_REPLY_GENERAL_SERVER_FAILURE, + CURLPX_REPLY_HOST_UNREACHABLE, + CURLPX_REPLY_NETWORK_UNREACHABLE, + CURLPX_REPLY_NOT_ALLOWED, + CURLPX_REPLY_TTL_EXPIRED, + CURLPX_REPLY_UNASSIGNED, + CURLPX_REQUEST_FAILED, + CURLPX_RESOLVE_HOST, + CURLPX_SEND_AUTH, + CURLPX_SEND_CONNECT, + CURLPX_SEND_REQUEST, + CURLPX_UNKNOWN_FAIL, + CURLPX_UNKNOWN_MODE, + CURLPX_USER_REJECTED, + CURLPX_LAST /* never use */ +} CURLproxycode; + +/* 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 + or WolfSSL SSL_CTX, + or an mbedTLS + mbedtls_ssl_config */ + 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_HTTPS = 2, /* added in 7.52.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 */ + +/* + * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options: + * + * CURLAUTH_NONE - No HTTP authentication + * CURLAUTH_BASIC - HTTP Basic authentication (default) + * CURLAUTH_DIGEST - HTTP Digest authentication + * CURLAUTH_NEGOTIATE - HTTP Negotiate (SPNEGO) authentication + * CURLAUTH_GSSNEGOTIATE - Alias for CURLAUTH_NEGOTIATE (deprecated) + * CURLAUTH_NTLM - HTTP NTLM authentication + * CURLAUTH_DIGEST_IE - HTTP Digest authentication with IE flavour + * CURLAUTH_NTLM_WB - HTTP NTLM authentication delegated to winbind helper + * CURLAUTH_BEARER - HTTP Bearer token authentication + * CURLAUTH_ONLY - Use together with a single other type to force no + * authentication or just that single type + * CURLAUTH_ANY - All fine types set + * CURLAUTH_ANYSAFE - All fine types except Basic + */ + +#define CURLAUTH_NONE ((unsigned long)0) +#define CURLAUTH_BASIC (((unsigned long)1)<<0) +#define CURLAUTH_DIGEST (((unsigned long)1)<<1) +#define CURLAUTH_NEGOTIATE (((unsigned long)1)<<2) +/* Deprecated since the advent of CURLAUTH_NEGOTIATE */ +#define CURLAUTH_GSSNEGOTIATE CURLAUTH_NEGOTIATE +/* Used for CURLOPT_SOCKS5_AUTH to stay terminologically correct */ +#define CURLAUTH_GSSAPI CURLAUTH_NEGOTIATE +#define CURLAUTH_NTLM (((unsigned long)1)<<3) +#define CURLAUTH_DIGEST_IE (((unsigned long)1)<<4) +#define CURLAUTH_NTLM_WB (((unsigned long)1)<<5) +#define CURLAUTH_BEARER (((unsigned long)1)<<6) +#define CURLAUTH_AWS_SIGV4 (((unsigned long)1)<<7) +#define CURLAUTH_ONLY (((unsigned long)1)<<31) +#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) +#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_AGENT (1<<4) /* agent (ssh-agent, pageant...) */ +#define CURLSSH_AUTH_GSSAPI (1<<5) /* gssapi (kerberos, ...) */ +#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 + +enum curl_khtype { + CURLKHTYPE_UNKNOWN, + CURLKHTYPE_RSA1, + CURLKHTYPE_RSA, + CURLKHTYPE_DSS, + CURLKHTYPE_ECDSA, + CURLKHTYPE_ED25519 +}; + +struct curl_khkey { + const char *key; /* points to a null-terminated string encoded with base64 + if len is zero, otherwise to the "raw" data */ + size_t len; + enum curl_khtype 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_FINE_REPLACE, /* accept and replace the wrong key*/ + 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; + +/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */ + +/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the + name of improving interoperability with older servers. Some SSL libraries + have introduced work-arounds for this flaw but those work-arounds sometimes + make the SSL communication fail. To regain functionality with those broken + servers, a user can this way allow the vulnerability back. */ +#define CURLSSLOPT_ALLOW_BEAST (1<<0) + +/* - NO_REVOKE tells libcurl to disable certificate revocation checks for those + SSL backends where such behavior is present. */ +#define CURLSSLOPT_NO_REVOKE (1<<1) + +/* - NO_PARTIALCHAIN tells libcurl to *NOT* accept a partial certificate chain + if possible. The OpenSSL backend has this ability. */ +#define CURLSSLOPT_NO_PARTIALCHAIN (1<<2) + +/* - REVOKE_BEST_EFFORT tells libcurl to ignore certificate revocation offline + checks and ignore missing revocation list for those SSL backends where such + behavior is present. */ +#define CURLSSLOPT_REVOKE_BEST_EFFORT (1<<3) + +/* - CURLSSLOPT_NATIVE_CA tells libcurl to use standard certificate store of + operating system. Currently implemented under MS-Windows. */ +#define CURLSSLOPT_NATIVE_CA (1<<4) + +/* - CURLSSLOPT_AUTO_CLIENT_CERT tells libcurl to automatically locate and use + a client certificate for authentication. (Schannel) */ +#define CURLSSLOPT_AUTO_CLIENT_CERT (1<<5) + +/* The default connection attempt delay in milliseconds for happy eyeballs. + CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS.3 and happy-eyeballs-timeout-ms.d document + this value, keep them in sync. */ +#define CURL_HET_DEFAULT 200L + +/* The default connection upkeep interval in milliseconds. */ +#define CURL_UPKEEP_INTERVAL_DEFAULT 60000L + +#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; + +/* bitmask defines for CURLOPT_HEADEROPT */ +#define CURLHEADER_UNIFIED 0 +#define CURLHEADER_SEPARATE (1<<0) + +/* CURLALTSVC_* are bits for the CURLOPT_ALTSVC_CTRL option */ +#define CURLALTSVC_READONLYFILE (1<<2) +#define CURLALTSVC_H1 (1<<3) +#define CURLALTSVC_H2 (1<<4) +#define CURLALTSVC_H3 (1<<5) + + +struct curl_hstsentry { + char *name; + size_t namelen; + unsigned int includeSubDomains:1; + char expire[18]; /* YYYYMMDD HH:MM:SS [null-terminated] */ +}; + +struct curl_index { + size_t index; /* the provided entry's "index" or count */ + size_t total; /* total number of entries to save */ +}; + +typedef enum { + CURLSTS_OK, + CURLSTS_DONE, + CURLSTS_FAIL +} CURLSTScode; + +typedef CURLSTScode (*curl_hstsread_callback)(CURL *easy, + struct curl_hstsentry *e, + void *userp); +typedef CURLSTScode (*curl_hstswrite_callback)(CURL *easy, + struct curl_hstsentry *e, + struct curl_index *i, + void *userp); + +/* CURLHSTS_* are bits for the CURLOPT_HSTS option */ +#define CURLHSTS_ENABLE (long)(1<<0) +#define CURLHSTS_READONLYFILE (long)(1<<1) + +/* 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_SMB (1<<26) +#define CURLPROTO_SMBS (1<<27) +#define CURLPROTO_MQTT (1<<28) +#define CURLPROTO_GOPHERS (1<<29) +#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 +#define CURLOPTTYPE_BLOB 40000 + +/* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the + string options from the header file */ + + +#define CURLOPT(na,t,nu) na = t + nu + +/* CURLOPT aliases that make no run-time difference */ + +/* 'char *' argument to a string with a trailing zero */ +#define CURLOPTTYPE_STRINGPOINT CURLOPTTYPE_OBJECTPOINT + +/* 'struct curl_slist *' argument */ +#define CURLOPTTYPE_SLISTPOINT CURLOPTTYPE_OBJECTPOINT + +/* 'void *' argument passed untouched to callback */ +#define CURLOPTTYPE_CBPOINT CURLOPTTYPE_OBJECTPOINT + +/* 'long' argument with a set of values/bitmask */ +#define CURLOPTTYPE_VALUES CURLOPTTYPE_LONG + +/* + * All CURLOPT_* values. + */ + +typedef enum { + /* This is the FILE * or void * the regular output should be written to. */ + CURLOPT(CURLOPT_WRITEDATA, CURLOPTTYPE_CBPOINT, 1), + + /* The full URL to get/put */ + CURLOPT(CURLOPT_URL, CURLOPTTYPE_STRINGPOINT, 2), + + /* Port number to connect to, if other than default. */ + CURLOPT(CURLOPT_PORT, CURLOPTTYPE_LONG, 3), + + /* Name of proxy to use. */ + CURLOPT(CURLOPT_PROXY, CURLOPTTYPE_STRINGPOINT, 4), + + /* "user:password;options" to use when fetching. */ + CURLOPT(CURLOPT_USERPWD, CURLOPTTYPE_STRINGPOINT, 5), + + /* "user:password" to use with proxy. */ + CURLOPT(CURLOPT_PROXYUSERPWD, CURLOPTTYPE_STRINGPOINT, 6), + + /* Range to get, specified as an ASCII string. */ + CURLOPT(CURLOPT_RANGE, CURLOPTTYPE_STRINGPOINT, 7), + + /* not used */ + + /* Specified file stream to upload from (use as input): */ + CURLOPT(CURLOPT_READDATA, CURLOPTTYPE_CBPOINT, 9), + + /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE + * bytes big. */ + CURLOPT(CURLOPT_ERRORBUFFER, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_WRITEFUNCTION, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_READFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 12), + + /* Time-out the read operation after this amount of seconds */ + CURLOPT(CURLOPT_TIMEOUT, CURLOPTTYPE_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. + */ + CURLOPT(CURLOPT_INFILESIZE, CURLOPTTYPE_LONG, 14), + + /* POST static input fields. */ + CURLOPT(CURLOPT_POSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 15), + + /* Set the referrer page (needed by some CGIs) */ + CURLOPT(CURLOPT_REFERER, CURLOPTTYPE_STRINGPOINT, 16), + + /* Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ + CURLOPT(CURLOPT_FTPPORT, CURLOPTTYPE_STRINGPOINT, 17), + + /* Set the User-Agent string (examined by some CGIs) */ + CURLOPT(CURLOPT_USERAGENT, CURLOPTTYPE_STRINGPOINT, 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" */ + CURLOPT(CURLOPT_LOW_SPEED_LIMIT, CURLOPTTYPE_LONG, 19), + + /* Set the "low speed time" */ + CURLOPT(CURLOPT_LOW_SPEED_TIME, CURLOPTTYPE_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. + */ + CURLOPT(CURLOPT_RESUME_FROM, CURLOPTTYPE_LONG, 21), + + /* Set cookie in request: */ + CURLOPT(CURLOPT_COOKIE, CURLOPTTYPE_STRINGPOINT, 22), + + /* This points to a linked list of headers, struct curl_slist kind. This + list is also used for RTSP (in spite of its name) */ + CURLOPT(CURLOPT_HTTPHEADER, CURLOPTTYPE_SLISTPOINT, 23), + + /* This points to a linked list of post entries, struct curl_httppost */ + CURLOPT(CURLOPT_HTTPPOST, CURLOPTTYPE_OBJECTPOINT, 24), + + /* name of the file keeping your private SSL-certificate */ + CURLOPT(CURLOPT_SSLCERT, CURLOPTTYPE_STRINGPOINT, 25), + + /* password for the SSL or SSH private key */ + CURLOPT(CURLOPT_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 26), + + /* send TYPE parameter? */ + CURLOPT(CURLOPT_CRLF, CURLOPTTYPE_LONG, 27), + + /* send linked-list of QUOTE commands */ + CURLOPT(CURLOPT_QUOTE, CURLOPTTYPE_SLISTPOINT, 28), + + /* send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ + CURLOPT(CURLOPT_HEADERDATA, CURLOPTTYPE_CBPOINT, 29), + + /* point to a file to read the initial cookies from, also enables + "cookie awareness" */ + CURLOPT(CURLOPT_COOKIEFILE, CURLOPTTYPE_STRINGPOINT, 31), + + /* What version to specifically try to use. + See CURL_SSLVERSION defines below. */ + CURLOPT(CURLOPT_SSLVERSION, CURLOPTTYPE_VALUES, 32), + + /* What kind of HTTP time condition to use, see defines */ + CURLOPT(CURLOPT_TIMECONDITION, CURLOPTTYPE_VALUES, 33), + + /* Time to use with the above condition. Specified in number of seconds + since 1 Jan 1970 */ + CURLOPT(CURLOPT_TIMEVALUE, CURLOPTTYPE_LONG, 34), + + /* 35 = OBSOLETE */ + + /* Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ + CURLOPT(CURLOPT_CUSTOMREQUEST, CURLOPTTYPE_STRINGPOINT, 36), + + /* FILE handle to use instead of stderr */ + CURLOPT(CURLOPT_STDERR, CURLOPTTYPE_OBJECTPOINT, 37), + + /* 38 is not used */ + + /* send linked-list of post-transfer QUOTE commands */ + CURLOPT(CURLOPT_POSTQUOTE, CURLOPTTYPE_SLISTPOINT, 39), + + /* OBSOLETE, do not use! */ + CURLOPT(CURLOPT_OBSOLETE40, CURLOPTTYPE_OBJECTPOINT, 40), + + /* talk a lot */ + CURLOPT(CURLOPT_VERBOSE, CURLOPTTYPE_LONG, 41), + + /* throw the header out too */ + CURLOPT(CURLOPT_HEADER, CURLOPTTYPE_LONG, 42), + + /* shut off the progress meter */ + CURLOPT(CURLOPT_NOPROGRESS, CURLOPTTYPE_LONG, 43), + + /* use HEAD to get http document */ + CURLOPT(CURLOPT_NOBODY, CURLOPTTYPE_LONG, 44), + + /* no output on http error codes >= 400 */ + CURLOPT(CURLOPT_FAILONERROR, CURLOPTTYPE_LONG, 45), + + /* this is an upload */ + CURLOPT(CURLOPT_UPLOAD, CURLOPTTYPE_LONG, 46), + + /* HTTP POST method */ + CURLOPT(CURLOPT_POST, CURLOPTTYPE_LONG, 47), + + /* bare names when listing directories */ + CURLOPT(CURLOPT_DIRLISTONLY, CURLOPTTYPE_LONG, 48), + + /* Append instead of overwrite on upload! */ + CURLOPT(CURLOPT_APPEND, CURLOPTTYPE_LONG, 50), + + /* Specify whether to read the user+password from the .netrc or the URL. + * This must be one of the CURL_NETRC_* enums below. */ + CURLOPT(CURLOPT_NETRC, CURLOPTTYPE_VALUES, 51), + + /* use Location: Luke! */ + CURLOPT(CURLOPT_FOLLOWLOCATION, CURLOPTTYPE_LONG, 52), + + /* transfer data in text/ASCII format */ + CURLOPT(CURLOPT_TRANSFERTEXT, CURLOPTTYPE_LONG, 53), + + /* HTTP PUT */ + CURLOPT(CURLOPT_PUT, CURLOPTTYPE_LONG, 54), + + /* 55 = OBSOLETE */ + + /* DEPRECATED + * Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_progress_callback + * prototype defines. */ + CURLOPT(CURLOPT_PROGRESSFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 56), + + /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION + callbacks */ + CURLOPT(CURLOPT_XFERINFODATA, CURLOPTTYPE_CBPOINT, 57), +#define CURLOPT_PROGRESSDATA CURLOPT_XFERINFODATA + + /* We want the referrer field set automatically when following locations */ + CURLOPT(CURLOPT_AUTOREFERER, CURLOPTTYPE_LONG, 58), + + /* Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + CURLOPT(CURLOPT_PROXYPORT, CURLOPTTYPE_LONG, 59), + + /* size of the POST input data, if strlen() is not good to use */ + CURLOPT(CURLOPT_POSTFIELDSIZE, CURLOPTTYPE_LONG, 60), + + /* tunnel non-http operations through a HTTP proxy */ + CURLOPT(CURLOPT_HTTPPROXYTUNNEL, CURLOPTTYPE_LONG, 61), + + /* Set the interface string to use as outgoing network interface */ + CURLOPT(CURLOPT_INTERFACE, CURLOPTTYPE_STRINGPOINT, 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. */ + CURLOPT(CURLOPT_KRBLEVEL, CURLOPTTYPE_STRINGPOINT, 63), + + /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ + CURLOPT(CURLOPT_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 64), + + /* The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_CAINFO, CURLOPTTYPE_STRINGPOINT, 65), + + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /* Maximum number of http redirects to follow */ + CURLOPT(CURLOPT_MAXREDIRS, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_FILETIME, CURLOPTTYPE_LONG, 69), + + /* This points to a linked list of telnet options */ + CURLOPT(CURLOPT_TELNETOPTIONS, CURLOPTTYPE_SLISTPOINT, 70), + + /* Max amount of cached alive connections */ + CURLOPT(CURLOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 71), + + /* OBSOLETE, do not use! */ + CURLOPT(CURLOPT_OBSOLETE72, CURLOPTTYPE_LONG, 72), + + /* 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. */ + CURLOPT(CURLOPT_FRESH_CONNECT, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_FORBID_REUSE, CURLOPTTYPE_LONG, 75), + + /* Set to a file name that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ + CURLOPT(CURLOPT_RANDOM_FILE, CURLOPTTYPE_STRINGPOINT, 76), + + /* Set to the Entropy Gathering Daemon socket pathname */ + CURLOPT(CURLOPT_EGDSOCKET, CURLOPTTYPE_STRINGPOINT, 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. */ + CURLOPT(CURLOPT_CONNECTTIMEOUT, CURLOPTTYPE_LONG, 78), + + /* Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CURLOPT(CURLOPT_HEADERFUNCTION, CURLOPTTYPE_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. + */ + CURLOPT(CURLOPT_HTTPGET, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_SSL_VERIFYHOST, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_COOKIEJAR, CURLOPTTYPE_STRINGPOINT, 82), + + /* Specify which SSL ciphers to use */ + CURLOPT(CURLOPT_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 83), + + /* Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + CURLOPT(CURLOPT_HTTP_VERSION, CURLOPTTYPE_VALUES, 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. */ + CURLOPT(CURLOPT_FTP_USE_EPSV, CURLOPTTYPE_LONG, 85), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ + CURLOPT(CURLOPT_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 86), + + /* name of the file keeping your private SSL-key */ + CURLOPT(CURLOPT_SSLKEY, CURLOPTTYPE_STRINGPOINT, 87), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ + CURLOPT(CURLOPT_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 88), + + /* crypto engine for the SSL-sub system */ + CURLOPT(CURLOPT_SSLENGINE, CURLOPTTYPE_STRINGPOINT, 89), + + /* set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + CURLOPT(CURLOPT_SSLENGINE_DEFAULT, CURLOPTTYPE_LONG, 90), + + /* Non-zero value means to use the global dns cache */ + /* DEPRECATED, do not use! */ + CURLOPT(CURLOPT_DNS_USE_GLOBAL_CACHE, CURLOPTTYPE_LONG, 91), + + /* DNS cache timeout */ + CURLOPT(CURLOPT_DNS_CACHE_TIMEOUT, CURLOPTTYPE_LONG, 92), + + /* send linked-list of pre-transfer QUOTE commands */ + CURLOPT(CURLOPT_PREQUOTE, CURLOPTTYPE_SLISTPOINT, 93), + + /* set the debug function */ + CURLOPT(CURLOPT_DEBUGFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 94), + + /* set the data for the debug function */ + CURLOPT(CURLOPT_DEBUGDATA, CURLOPTTYPE_CBPOINT, 95), + + /* mark this as start of a cookie session */ + CURLOPT(CURLOPT_COOKIESESSION, CURLOPTTYPE_LONG, 96), + + /* The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_CAPATH, CURLOPTTYPE_STRINGPOINT, 97), + + /* Instruct libcurl to use a smaller receive buffer */ + CURLOPT(CURLOPT_BUFFERSIZE, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_NOSIGNAL, CURLOPTTYPE_LONG, 99), + + /* Provide a CURLShare for mutexing non-ts data */ + CURLOPT(CURLOPT_SHARE, CURLOPTTYPE_OBJECTPOINT, 100), + + /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), + CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and + CURLPROXY_SOCKS5. */ + CURLOPT(CURLOPT_PROXYTYPE, CURLOPTTYPE_VALUES, 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 */ + CURLOPT(CURLOPT_ACCEPT_ENCODING, CURLOPTTYPE_STRINGPOINT, 102), + + /* Set pointer to private data */ + CURLOPT(CURLOPT_PRIVATE, CURLOPTTYPE_OBJECTPOINT, 103), + + /* Set aliases for HTTP 200 in the HTTP Response header */ + CURLOPT(CURLOPT_HTTP200ALIASES, CURLOPTTYPE_SLISTPOINT, 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. */ + CURLOPT(CURLOPT_UNRESTRICTED_AUTH, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_FTP_USE_EPRT, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_HTTPAUTH, CURLOPTTYPE_VALUES, 107), + + /* Set the ssl context callback function, currently only for OpenSSL or + WolfSSL ssl_ctx, or mbedTLS mbedtls_ssl_config in the second argument. + The function must match the curl_ssl_ctx_callback prototype. */ + CURLOPT(CURLOPT_SSL_CTX_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 108), + + /* Set the userdata for the ssl context callback function's third + argument */ + CURLOPT(CURLOPT_SSL_CTX_DATA, CURLOPTTYPE_CBPOINT, 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. + */ + CURLOPT(CURLOPT_FTP_CREATE_MISSING_DIRS, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_PROXYAUTH, CURLOPTTYPE_VALUES, 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. */ + CURLOPT(CURLOPT_FTP_RESPONSE_TIMEOUT, CURLOPTTYPE_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 use those IP versions only. This only has effect on + systems with support for more than one, i.e IPv4 _and_ IPv6. */ + CURLOPT(CURLOPT_IPRESOLVE, CURLOPTTYPE_VALUES, 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. */ + CURLOPT(CURLOPT_MAXFILESIZE, CURLOPTTYPE_LONG, 114), + + /* See the comment for INFILESIZE above, but in short, specifies + * the size of the file being uploaded. -1 means unknown. + */ + CURLOPT(CURLOPT_INFILESIZE_LARGE, CURLOPTTYPE_OFF_T, 115), + + /* Sets the continuation offset. There is also a CURLOPTTYPE_LONG version + * of this; look above for RESUME_FROM. + */ + CURLOPT(CURLOPT_RESUME_FROM_LARGE, CURLOPTTYPE_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. + */ + CURLOPT(CURLOPT_MAXFILESIZE_LARGE, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_NETRC_FILE, CURLOPTTYPE_STRINGPOINT, 118), + + /* Enable SSL/TLS for FTP, pick one of: + 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 + */ + CURLOPT(CURLOPT_USE_SSL, CURLOPTTYPE_VALUES, 119), + + /* The _LARGE version of the standard POSTFIELDSIZE option */ + CURLOPT(CURLOPT_POSTFIELDSIZE_LARGE, CURLOPTTYPE_OFF_T, 120), + + /* Enable/disable the TCP Nagle algorithm */ + CURLOPT(CURLOPT_TCP_NODELAY, CURLOPTTYPE_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 + */ + CURLOPT(CURLOPT_FTPSSLAUTH, CURLOPTTYPE_VALUES, 129), + + CURLOPT(CURLOPT_IOCTLFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 130), + CURLOPT(CURLOPT_IOCTLDATA, CURLOPTTYPE_CBPOINT, 131), + + /* 132 OBSOLETE. Gone in 7.16.0 */ + /* 133 OBSOLETE. Gone in 7.16.0 */ + + /* null-terminated string for pass on to the FTP server when asked for + "account" info */ + CURLOPT(CURLOPT_FTP_ACCOUNT, CURLOPTTYPE_STRINGPOINT, 134), + + /* feed cookie into cookie engine */ + CURLOPT(CURLOPT_COOKIELIST, CURLOPTTYPE_STRINGPOINT, 135), + + /* ignore Content-Length */ + CURLOPT(CURLOPT_IGNORE_CONTENT_LENGTH, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_FTP_SKIP_PASV_IP, CURLOPTTYPE_LONG, 137), + + /* Select "file method" to use when doing FTP, see the curl_ftpmethod + above. */ + CURLOPT(CURLOPT_FTP_FILEMETHOD, CURLOPTTYPE_VALUES, 138), + + /* Local port number to bind the socket to */ + CURLOPT(CURLOPT_LOCALPORT, CURLOPTTYPE_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. + */ + CURLOPT(CURLOPT_LOCALPORTRANGE, CURLOPTTYPE_LONG, 140), + + /* no transfer, set up connection and let application use the socket by + extracting it with CURLINFO_LASTSOCKET */ + CURLOPT(CURLOPT_CONNECT_ONLY, CURLOPTTYPE_LONG, 141), + + /* Function that will be called to convert from the + network encoding (instead of using the iconv calls in libcurl) */ + CURLOPT(CURLOPT_CONV_FROM_NETWORK_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 142), + + /* Function that will be called to convert to the + network encoding (instead of using the iconv calls in libcurl) */ + CURLOPT(CURLOPT_CONV_TO_NETWORK_FUNCTION, CURLOPTTYPE_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 */ + CURLOPT(CURLOPT_CONV_FROM_UTF8_FUNCTION, CURLOPTTYPE_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 */ + CURLOPT(CURLOPT_MAX_SEND_SPEED_LARGE, CURLOPTTYPE_OFF_T, 145), + CURLOPT(CURLOPT_MAX_RECV_SPEED_LARGE, CURLOPTTYPE_OFF_T, 146), + + /* Pointer to command string to send if USER/PASS fails. */ + CURLOPT(CURLOPT_FTP_ALTERNATIVE_TO_USER, CURLOPTTYPE_STRINGPOINT, 147), + + /* callback function for setting socket options */ + CURLOPT(CURLOPT_SOCKOPTFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 148), + CURLOPT(CURLOPT_SOCKOPTDATA, CURLOPTTYPE_CBPOINT, 149), + + /* set to 0 to disable session ID re-use for this transfer, default is + enabled (== 1) */ + CURLOPT(CURLOPT_SSL_SESSIONID_CACHE, CURLOPTTYPE_LONG, 150), + + /* allowed SSH authentication methods */ + CURLOPT(CURLOPT_SSH_AUTH_TYPES, CURLOPTTYPE_VALUES, 151), + + /* Used by scp/sftp to do public/private key authentication */ + CURLOPT(CURLOPT_SSH_PUBLIC_KEYFILE, CURLOPTTYPE_STRINGPOINT, 152), + CURLOPT(CURLOPT_SSH_PRIVATE_KEYFILE, CURLOPTTYPE_STRINGPOINT, 153), + + /* Send CCC (Clear Command Channel) after authentication */ + CURLOPT(CURLOPT_FTP_SSL_CCC, CURLOPTTYPE_LONG, 154), + + /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ + CURLOPT(CURLOPT_TIMEOUT_MS, CURLOPTTYPE_LONG, 155), + CURLOPT(CURLOPT_CONNECTTIMEOUT_MS, CURLOPTTYPE_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 */ + CURLOPT(CURLOPT_HTTP_TRANSFER_DECODING, CURLOPTTYPE_LONG, 157), + CURLOPT(CURLOPT_HTTP_CONTENT_DECODING, CURLOPTTYPE_LONG, 158), + + /* Permission used when creating new files and directories on the remote + server for protocols that support it, SFTP/SCP/FILE */ + CURLOPT(CURLOPT_NEW_FILE_PERMS, CURLOPTTYPE_LONG, 159), + CURLOPT(CURLOPT_NEW_DIRECTORY_PERMS, CURLOPTTYPE_LONG, 160), + + /* Set the behavior of POST when redirecting. Values must be set to one + of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ + CURLOPT(CURLOPT_POSTREDIR, CURLOPTTYPE_VALUES, 161), + + /* used by scp/sftp to verify the host's public key */ + CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_MD5, CURLOPTTYPE_STRINGPOINT, 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 */ + CURLOPT(CURLOPT_OPENSOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 163), + CURLOPT(CURLOPT_OPENSOCKETDATA, CURLOPTTYPE_CBPOINT, 164), + + /* POST volatile input fields. */ + CURLOPT(CURLOPT_COPYPOSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 165), + + /* set transfer mode (;type=) when doing FTP via an HTTP proxy */ + CURLOPT(CURLOPT_PROXY_TRANSFER_MODE, CURLOPTTYPE_LONG, 166), + + /* Callback function for seeking in the input stream */ + CURLOPT(CURLOPT_SEEKFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 167), + CURLOPT(CURLOPT_SEEKDATA, CURLOPTTYPE_CBPOINT, 168), + + /* CRL file */ + CURLOPT(CURLOPT_CRLFILE, CURLOPTTYPE_STRINGPOINT, 169), + + /* Issuer certificate */ + CURLOPT(CURLOPT_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 170), + + /* (IPv6) Address scope */ + CURLOPT(CURLOPT_ADDRESS_SCOPE, CURLOPTTYPE_LONG, 171), + + /* Collect certificate chain info and allow it to get retrievable with + CURLINFO_CERTINFO after the transfer is complete. */ + CURLOPT(CURLOPT_CERTINFO, CURLOPTTYPE_LONG, 172), + + /* "name" and "pwd" to use when fetching. */ + CURLOPT(CURLOPT_USERNAME, CURLOPTTYPE_STRINGPOINT, 173), + CURLOPT(CURLOPT_PASSWORD, CURLOPTTYPE_STRINGPOINT, 174), + + /* "name" and "pwd" to use with Proxy when fetching. */ + CURLOPT(CURLOPT_PROXYUSERNAME, CURLOPTTYPE_STRINGPOINT, 175), + CURLOPT(CURLOPT_PROXYPASSWORD, CURLOPTTYPE_STRINGPOINT, 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. */ + CURLOPT(CURLOPT_NOPROXY, CURLOPTTYPE_STRINGPOINT, 177), + + /* block size for TFTP transfers */ + CURLOPT(CURLOPT_TFTP_BLKSIZE, CURLOPTTYPE_LONG, 178), + + /* Socks Service */ + /* DEPRECATED, do not use! */ + CURLOPT(CURLOPT_SOCKS5_GSSAPI_SERVICE, CURLOPTTYPE_STRINGPOINT, 179), + + /* Socks Service */ + CURLOPT(CURLOPT_SOCKS5_GSSAPI_NEC, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_PROTOCOLS, CURLOPTTYPE_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. */ + CURLOPT(CURLOPT_REDIR_PROTOCOLS, CURLOPTTYPE_LONG, 182), + + /* set the SSH knownhost file name to use */ + CURLOPT(CURLOPT_SSH_KNOWNHOSTS, CURLOPTTYPE_STRINGPOINT, 183), + + /* set the SSH host key callback, must point to a curl_sshkeycallback + function */ + CURLOPT(CURLOPT_SSH_KEYFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 184), + + /* set the SSH host key callback custom pointer */ + CURLOPT(CURLOPT_SSH_KEYDATA, CURLOPTTYPE_CBPOINT, 185), + + /* set the SMTP mail originator */ + CURLOPT(CURLOPT_MAIL_FROM, CURLOPTTYPE_STRINGPOINT, 186), + + /* set the list of SMTP mail receiver(s) */ + CURLOPT(CURLOPT_MAIL_RCPT, CURLOPTTYPE_SLISTPOINT, 187), + + /* FTP: send PRET before PASV */ + CURLOPT(CURLOPT_FTP_USE_PRET, CURLOPTTYPE_LONG, 188), + + /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ + CURLOPT(CURLOPT_RTSP_REQUEST, CURLOPTTYPE_VALUES, 189), + + /* The RTSP session identifier */ + CURLOPT(CURLOPT_RTSP_SESSION_ID, CURLOPTTYPE_STRINGPOINT, 190), + + /* The RTSP stream URI */ + CURLOPT(CURLOPT_RTSP_STREAM_URI, CURLOPTTYPE_STRINGPOINT, 191), + + /* The Transport: header to use in RTSP requests */ + CURLOPT(CURLOPT_RTSP_TRANSPORT, CURLOPTTYPE_STRINGPOINT, 192), + + /* Manually initialize the client RTSP CSeq for this handle */ + CURLOPT(CURLOPT_RTSP_CLIENT_CSEQ, CURLOPTTYPE_LONG, 193), + + /* Manually initialize the server RTSP CSeq for this handle */ + CURLOPT(CURLOPT_RTSP_SERVER_CSEQ, CURLOPTTYPE_LONG, 194), + + /* The stream to pass to INTERLEAVEFUNCTION. */ + CURLOPT(CURLOPT_INTERLEAVEDATA, CURLOPTTYPE_CBPOINT, 195), + + /* Let the application define a custom write method for RTP data */ + CURLOPT(CURLOPT_INTERLEAVEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 196), + + /* Turn on wildcard matching */ + CURLOPT(CURLOPT_WILDCARDMATCH, CURLOPTTYPE_LONG, 197), + + /* Directory matching callback called before downloading of an + individual file (chunk) started */ + CURLOPT(CURLOPT_CHUNK_BGN_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 198), + + /* Directory matching callback called after the file (chunk) + was downloaded, or skipped */ + CURLOPT(CURLOPT_CHUNK_END_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 199), + + /* Change match (fnmatch-like) callback for wildcard matching */ + CURLOPT(CURLOPT_FNMATCH_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 200), + + /* Let the application define custom chunk data pointer */ + CURLOPT(CURLOPT_CHUNK_DATA, CURLOPTTYPE_CBPOINT, 201), + + /* FNMATCH_FUNCTION user pointer */ + CURLOPT(CURLOPT_FNMATCH_DATA, CURLOPTTYPE_CBPOINT, 202), + + /* send linked-list of name:port:address sets */ + CURLOPT(CURLOPT_RESOLVE, CURLOPTTYPE_SLISTPOINT, 203), + + /* Set a username for authenticated TLS */ + CURLOPT(CURLOPT_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 204), + + /* Set a password for authenticated TLS */ + CURLOPT(CURLOPT_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 205), + + /* Set authentication type for authenticated TLS */ + CURLOPT(CURLOPT_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 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. + + */ + CURLOPT(CURLOPT_TRANSFER_ENCODING, CURLOPTTYPE_LONG, 207), + + /* Callback function for closing socket (instead of close(2)). The callback + should have type curl_closesocket_callback */ + CURLOPT(CURLOPT_CLOSESOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 208), + CURLOPT(CURLOPT_CLOSESOCKETDATA, CURLOPTTYPE_CBPOINT, 209), + + /* allow GSSAPI credential delegation */ + CURLOPT(CURLOPT_GSSAPI_DELEGATION, CURLOPTTYPE_VALUES, 210), + + /* Set the name servers to use for DNS resolution */ + CURLOPT(CURLOPT_DNS_SERVERS, CURLOPTTYPE_STRINGPOINT, 211), + + /* Time-out accept operations (currently for FTP only) after this amount + of milliseconds. */ + CURLOPT(CURLOPT_ACCEPTTIMEOUT_MS, CURLOPTTYPE_LONG, 212), + + /* Set TCP keepalive */ + CURLOPT(CURLOPT_TCP_KEEPALIVE, CURLOPTTYPE_LONG, 213), + + /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */ + CURLOPT(CURLOPT_TCP_KEEPIDLE, CURLOPTTYPE_LONG, 214), + CURLOPT(CURLOPT_TCP_KEEPINTVL, CURLOPTTYPE_LONG, 215), + + /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */ + CURLOPT(CURLOPT_SSL_OPTIONS, CURLOPTTYPE_VALUES, 216), + + /* Set the SMTP auth originator */ + CURLOPT(CURLOPT_MAIL_AUTH, CURLOPTTYPE_STRINGPOINT, 217), + + /* Enable/disable SASL initial response */ + CURLOPT(CURLOPT_SASL_IR, CURLOPTTYPE_LONG, 218), + + /* Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_xferinfo_callback + * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */ + CURLOPT(CURLOPT_XFERINFOFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 219), + + /* The XOAUTH2 bearer token */ + CURLOPT(CURLOPT_XOAUTH2_BEARER, CURLOPTTYPE_STRINGPOINT, 220), + + /* Set the interface string to use as outgoing network + * interface for DNS requests. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_INTERFACE, CURLOPTTYPE_STRINGPOINT, 221), + + /* Set the local IPv4 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_LOCAL_IP4, CURLOPTTYPE_STRINGPOINT, 222), + + /* Set the local IPv6 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_LOCAL_IP6, CURLOPTTYPE_STRINGPOINT, 223), + + /* Set authentication options directly */ + CURLOPT(CURLOPT_LOGIN_OPTIONS, CURLOPTTYPE_STRINGPOINT, 224), + + /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */ + CURLOPT(CURLOPT_SSL_ENABLE_NPN, CURLOPTTYPE_LONG, 225), + + /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */ + CURLOPT(CURLOPT_SSL_ENABLE_ALPN, CURLOPTTYPE_LONG, 226), + + /* Time to wait for a response to a HTTP request containing an + * Expect: 100-continue header before sending the data anyway. */ + CURLOPT(CURLOPT_EXPECT_100_TIMEOUT_MS, CURLOPTTYPE_LONG, 227), + + /* This points to a linked list of headers used for proxy requests only, + struct curl_slist kind */ + CURLOPT(CURLOPT_PROXYHEADER, CURLOPTTYPE_SLISTPOINT, 228), + + /* Pass in a bitmask of "header options" */ + CURLOPT(CURLOPT_HEADEROPT, CURLOPTTYPE_VALUES, 229), + + /* The public key in DER form used to validate the peer public key + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 230), + + /* Path to Unix domain socket */ + CURLOPT(CURLOPT_UNIX_SOCKET_PATH, CURLOPTTYPE_STRINGPOINT, 231), + + /* Set if we should verify the certificate status. */ + CURLOPT(CURLOPT_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 232), + + /* Set if we should enable TLS false start. */ + CURLOPT(CURLOPT_SSL_FALSESTART, CURLOPTTYPE_LONG, 233), + + /* Do not squash dot-dot sequences */ + CURLOPT(CURLOPT_PATH_AS_IS, CURLOPTTYPE_LONG, 234), + + /* Proxy Service Name */ + CURLOPT(CURLOPT_PROXY_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 235), + + /* Service Name */ + CURLOPT(CURLOPT_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 236), + + /* Wait/don't wait for pipe/mutex to clarify */ + CURLOPT(CURLOPT_PIPEWAIT, CURLOPTTYPE_LONG, 237), + + /* Set the protocol used when curl is given a URL without a protocol */ + CURLOPT(CURLOPT_DEFAULT_PROTOCOL, CURLOPTTYPE_STRINGPOINT, 238), + + /* Set stream weight, 1 - 256 (default is 16) */ + CURLOPT(CURLOPT_STREAM_WEIGHT, CURLOPTTYPE_LONG, 239), + + /* Set stream dependency on another CURL handle */ + CURLOPT(CURLOPT_STREAM_DEPENDS, CURLOPTTYPE_OBJECTPOINT, 240), + + /* Set E-xclusive stream dependency on another CURL handle */ + CURLOPT(CURLOPT_STREAM_DEPENDS_E, CURLOPTTYPE_OBJECTPOINT, 241), + + /* Do not send any tftp option requests to the server */ + CURLOPT(CURLOPT_TFTP_NO_OPTIONS, CURLOPTTYPE_LONG, 242), + + /* Linked-list of host:port:connect-to-host:connect-to-port, + overrides the URL's host:port (only for the network layer) */ + CURLOPT(CURLOPT_CONNECT_TO, CURLOPTTYPE_SLISTPOINT, 243), + + /* Set TCP Fast Open */ + CURLOPT(CURLOPT_TCP_FASTOPEN, CURLOPTTYPE_LONG, 244), + + /* Continue to send data if the server responds early with an + * HTTP status code >= 300 */ + CURLOPT(CURLOPT_KEEP_SENDING_ON_ERROR, CURLOPTTYPE_LONG, 245), + + /* The CApath or CAfile used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_CAINFO, CURLOPTTYPE_STRINGPOINT, 246), + + /* The CApath directory used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_CAPATH, CURLOPTTYPE_STRINGPOINT, 247), + + /* Set if we should verify the proxy in ssl handshake, + set 1 to verify. */ + CURLOPT(CURLOPT_PROXY_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 248), + + /* Set if we should verify the Common name from the proxy certificate in ssl + * handshake, set 1 to check existence, 2 to ensure that it matches + * the provided hostname. */ + CURLOPT(CURLOPT_PROXY_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 249), + + /* What version to specifically try to use for proxy. + See CURL_SSLVERSION defines below. */ + CURLOPT(CURLOPT_PROXY_SSLVERSION, CURLOPTTYPE_VALUES, 250), + + /* Set a username for authenticated TLS for proxy */ + CURLOPT(CURLOPT_PROXY_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 251), + + /* Set a password for authenticated TLS for proxy */ + CURLOPT(CURLOPT_PROXY_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 252), + + /* Set authentication type for authenticated TLS for proxy */ + CURLOPT(CURLOPT_PROXY_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 253), + + /* name of the file keeping your private SSL-certificate for proxy */ + CURLOPT(CURLOPT_PROXY_SSLCERT, CURLOPTTYPE_STRINGPOINT, 254), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for + proxy */ + CURLOPT(CURLOPT_PROXY_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 255), + + /* name of the file keeping your private SSL-key for proxy */ + CURLOPT(CURLOPT_PROXY_SSLKEY, CURLOPTTYPE_STRINGPOINT, 256), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for + proxy */ + CURLOPT(CURLOPT_PROXY_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 257), + + /* password for the SSL private key for proxy */ + CURLOPT(CURLOPT_PROXY_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 258), + + /* Specify which SSL ciphers to use for proxy */ + CURLOPT(CURLOPT_PROXY_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 259), + + /* CRL file for proxy */ + CURLOPT(CURLOPT_PROXY_CRLFILE, CURLOPTTYPE_STRINGPOINT, 260), + + /* Enable/disable specific SSL features with a bitmask for proxy, see + CURLSSLOPT_* */ + CURLOPT(CURLOPT_PROXY_SSL_OPTIONS, CURLOPTTYPE_LONG, 261), + + /* Name of pre proxy to use. */ + CURLOPT(CURLOPT_PRE_PROXY, CURLOPTTYPE_STRINGPOINT, 262), + + /* The public key in DER form used to validate the proxy public key + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 263), + + /* Path to an abstract Unix domain socket */ + CURLOPT(CURLOPT_ABSTRACT_UNIX_SOCKET, CURLOPTTYPE_STRINGPOINT, 264), + + /* Suppress proxy CONNECT response headers from user callbacks */ + CURLOPT(CURLOPT_SUPPRESS_CONNECT_HEADERS, CURLOPTTYPE_LONG, 265), + + /* The request target, instead of extracted from the URL */ + CURLOPT(CURLOPT_REQUEST_TARGET, CURLOPTTYPE_STRINGPOINT, 266), + + /* bitmask of allowed auth methods for connections to SOCKS5 proxies */ + CURLOPT(CURLOPT_SOCKS5_AUTH, CURLOPTTYPE_LONG, 267), + + /* Enable/disable SSH compression */ + CURLOPT(CURLOPT_SSH_COMPRESSION, CURLOPTTYPE_LONG, 268), + + /* Post MIME data. */ + CURLOPT(CURLOPT_MIMEPOST, CURLOPTTYPE_OBJECTPOINT, 269), + + /* Time to use with the CURLOPT_TIMECONDITION. Specified in number of + seconds since 1 Jan 1970. */ + CURLOPT(CURLOPT_TIMEVALUE_LARGE, CURLOPTTYPE_OFF_T, 270), + + /* Head start in milliseconds to give happy eyeballs. */ + CURLOPT(CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS, CURLOPTTYPE_LONG, 271), + + /* Function that will be called before a resolver request is made */ + CURLOPT(CURLOPT_RESOLVER_START_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 272), + + /* User data to pass to the resolver start callback. */ + CURLOPT(CURLOPT_RESOLVER_START_DATA, CURLOPTTYPE_CBPOINT, 273), + + /* send HAProxy PROXY protocol header? */ + CURLOPT(CURLOPT_HAPROXYPROTOCOL, CURLOPTTYPE_LONG, 274), + + /* shuffle addresses before use when DNS returns multiple */ + CURLOPT(CURLOPT_DNS_SHUFFLE_ADDRESSES, CURLOPTTYPE_LONG, 275), + + /* Specify which TLS 1.3 ciphers suites to use */ + CURLOPT(CURLOPT_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 276), + CURLOPT(CURLOPT_PROXY_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 277), + + /* Disallow specifying username/login in URL. */ + CURLOPT(CURLOPT_DISALLOW_USERNAME_IN_URL, CURLOPTTYPE_LONG, 278), + + /* DNS-over-HTTPS URL */ + CURLOPT(CURLOPT_DOH_URL, CURLOPTTYPE_STRINGPOINT, 279), + + /* Preferred buffer size to use for uploads */ + CURLOPT(CURLOPT_UPLOAD_BUFFERSIZE, CURLOPTTYPE_LONG, 280), + + /* Time in ms between connection upkeep calls for long-lived connections. */ + CURLOPT(CURLOPT_UPKEEP_INTERVAL_MS, CURLOPTTYPE_LONG, 281), + + /* Specify URL using CURL URL API. */ + CURLOPT(CURLOPT_CURLU, CURLOPTTYPE_OBJECTPOINT, 282), + + /* add trailing data just after no more data is available */ + CURLOPT(CURLOPT_TRAILERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 283), + + /* pointer to be passed to HTTP_TRAILER_FUNCTION */ + CURLOPT(CURLOPT_TRAILERDATA, CURLOPTTYPE_CBPOINT, 284), + + /* set this to 1L to allow HTTP/0.9 responses or 0L to disallow */ + CURLOPT(CURLOPT_HTTP09_ALLOWED, CURLOPTTYPE_LONG, 285), + + /* alt-svc control bitmask */ + CURLOPT(CURLOPT_ALTSVC_CTRL, CURLOPTTYPE_LONG, 286), + + /* alt-svc cache file name to possibly read from/write to */ + CURLOPT(CURLOPT_ALTSVC, CURLOPTTYPE_STRINGPOINT, 287), + + /* maximum age (idle time) of a connection to consider it for reuse + * (in seconds) */ + CURLOPT(CURLOPT_MAXAGE_CONN, CURLOPTTYPE_LONG, 288), + + /* SASL authorisation identity */ + CURLOPT(CURLOPT_SASL_AUTHZID, CURLOPTTYPE_STRINGPOINT, 289), + + /* allow RCPT TO command to fail for some recipients */ + CURLOPT(CURLOPT_MAIL_RCPT_ALLLOWFAILS, CURLOPTTYPE_LONG, 290), + + /* the private SSL-certificate as a "blob" */ + CURLOPT(CURLOPT_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 291), + CURLOPT(CURLOPT_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 292), + CURLOPT(CURLOPT_PROXY_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 293), + CURLOPT(CURLOPT_PROXY_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 294), + CURLOPT(CURLOPT_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 295), + + /* Issuer certificate for proxy */ + CURLOPT(CURLOPT_PROXY_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 296), + CURLOPT(CURLOPT_PROXY_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 297), + + /* the EC curves requested by the TLS client (RFC 8422, 5.1); + * OpenSSL support via 'set_groups'/'set_curves': + * https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set1_groups.html + */ + CURLOPT(CURLOPT_SSL_EC_CURVES, CURLOPTTYPE_STRINGPOINT, 298), + + /* HSTS bitmask */ + CURLOPT(CURLOPT_HSTS_CTRL, CURLOPTTYPE_LONG, 299), + /* HSTS file name */ + CURLOPT(CURLOPT_HSTS, CURLOPTTYPE_STRINGPOINT, 300), + + /* HSTS read callback */ + CURLOPT(CURLOPT_HSTSREADFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 301), + CURLOPT(CURLOPT_HSTSREADDATA, CURLOPTTYPE_CBPOINT, 302), + + /* HSTS write callback */ + CURLOPT(CURLOPT_HSTSWRITEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 303), + CURLOPT(CURLOPT_HSTSWRITEDATA, CURLOPTTYPE_CBPOINT, 304), + + /* Parameters for V4 signature */ + CURLOPT(CURLOPT_AWS_SIGV4, CURLOPTTYPE_STRINGPOINT, 305), + + /* Same as CURLOPT_SSL_VERIFYPEER but for DoH (DNS-over-HTTPS) servers. */ + CURLOPT(CURLOPT_DOH_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 306), + + /* Same as CURLOPT_SSL_VERIFYHOST but for DoH (DNS-over-HTTPS) servers. */ + CURLOPT(CURLOPT_DOH_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 307), + + /* Same as CURLOPT_SSL_VERIFYSTATUS but for DoH (DNS-over-HTTPS) servers. */ + CURLOPT(CURLOPT_DOH_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 308), + + /* The CA certificates as "blob" used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_CAINFO_BLOB, CURLOPTTYPE_BLOB, 309), + + /* The CA certificates as "blob" used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_CAINFO_BLOB, CURLOPTTYPE_BLOB, 310), + + /* used by scp/sftp to verify the host's public key */ + CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256, CURLOPTTYPE_STRINGPOINT, 311), + + /* Function that will be called immediately before the initial request + is made on a connection (after any protocol negotiation step). */ + CURLOPT(CURLOPT_PREREQFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 312), + + /* Data passed to the CURLOPT_PREREQFUNCTION callback */ + CURLOPT(CURLOPT_PREREQDATA, CURLOPTTYPE_CBPOINT, 313), + + /* maximum age (since creation) of a connection to consider it for reuse + * (in seconds) */ + CURLOPT(CURLOPT_MAXLIFETIME_CONN, CURLOPTTYPE_LONG, 314), + + /* Set MIME option flags. */ + CURLOPT(CURLOPT_MIME_OPTIONS, CURLOPTTYPE_LONG, 315), + + 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, uses addresses to all IP + versions that your system allows */ +#define CURL_IPRESOLVE_V4 1 /* uses only IPv4 addresses/connections */ +#define CURL_IPRESOLVE_V6 2 /* uses only IPv6 addresses/connections */ + + /* three convenient "aliases" that follow the name scheme better */ +#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_2_0, /* please use HTTP 2 in the request */ + CURL_HTTP_VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */ + CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE, /* please use HTTP 2 without HTTP/1.1 + Upgrade */ + CURL_HTTP_VERSION_3 = 30, /* Makes use of explicit HTTP/3 without fallback. + Use CURLOPT_ALTSVC to enable HTTP/3 upgrade */ + CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ +}; + +/* Convenience definition simple because the name of the version is HTTP/2 and + not 2.0. The 2_0 version of the enum name was set while the version was + still planned to be 2.0 and we stick to it for compatibility. */ +#define CURL_HTTP_VERSION_2 CURL_HTTP_VERSION_2_0 + +/* + * 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, /* TLS 1.x */ + CURL_SSLVERSION_SSLv2, + CURL_SSLVERSION_SSLv3, + CURL_SSLVERSION_TLSv1_0, + CURL_SSLVERSION_TLSv1_1, + CURL_SSLVERSION_TLSv1_2, + CURL_SSLVERSION_TLSv1_3, + + CURL_SSLVERSION_LAST /* never use, keep last */ +}; + +enum { + CURL_SSLVERSION_MAX_NONE = 0, + CURL_SSLVERSION_MAX_DEFAULT = (CURL_SSLVERSION_TLSv1 << 16), + CURL_SSLVERSION_MAX_TLSv1_0 = (CURL_SSLVERSION_TLSv1_0 << 16), + CURL_SSLVERSION_MAX_TLSv1_1 = (CURL_SSLVERSION_TLSv1_1 << 16), + CURL_SSLVERSION_MAX_TLSv1_2 = (CURL_SSLVERSION_TLSv1_2 << 16), + CURL_SSLVERSION_MAX_TLSv1_3 = (CURL_SSLVERSION_TLSv1_3 << 16), + + /* never use, keep last */ + CURL_SSLVERSION_MAX_LAST = (CURL_SSLVERSION_LAST << 16) +}; + +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, CURL_REDIR_POST_302 and CURL_REDIR_POST_303 + can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302 + | CURL_REDIR_POST_303 == 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_303 4 +#define CURL_REDIR_POST_ALL \ + (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303) + +typedef enum { + CURL_TIMECOND_NONE, + + CURL_TIMECOND_IFMODSINCE, + CURL_TIMECOND_IFUNMODSINCE, + CURL_TIMECOND_LASTMOD, + + CURL_TIMECOND_LAST +} curl_TimeCond; + +/* Special size_t value signaling a null-terminated string. */ +#define CURL_ZERO_TERMINATED ((size_t) -1) + +/* curl_strequal() and curl_strnequal() are subject for removal in a future + release */ +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); + +/* Mime/form handling support. */ +typedef struct curl_mime curl_mime; /* Mime context. */ +typedef struct curl_mimepart curl_mimepart; /* Mime part context. */ + +/* CURLMIMEOPT_ defines are for the CURLOPT_MIME_OPTIONS option. */ +#define CURLMIMEOPT_FORMESCAPE (1<<0) /* Use backslash-escaping for forms. */ + +/* + * NAME curl_mime_init() + * + * DESCRIPTION + * + * Create a mime context and return its handle. The easy parameter is the + * target handle. + */ +CURL_EXTERN curl_mime *curl_mime_init(CURL *easy); + +/* + * NAME curl_mime_free() + * + * DESCRIPTION + * + * release a mime handle and its substructures. + */ +CURL_EXTERN void curl_mime_free(curl_mime *mime); + +/* + * NAME curl_mime_addpart() + * + * DESCRIPTION + * + * Append a new empty part to the given mime context and return a handle to + * the created part. + */ +CURL_EXTERN curl_mimepart *curl_mime_addpart(curl_mime *mime); + +/* + * NAME curl_mime_name() + * + * DESCRIPTION + * + * Set mime/form part name. + */ +CURL_EXTERN CURLcode curl_mime_name(curl_mimepart *part, const char *name); + +/* + * NAME curl_mime_filename() + * + * DESCRIPTION + * + * Set mime part remote file name. + */ +CURL_EXTERN CURLcode curl_mime_filename(curl_mimepart *part, + const char *filename); + +/* + * NAME curl_mime_type() + * + * DESCRIPTION + * + * Set mime part type. + */ +CURL_EXTERN CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype); + +/* + * NAME curl_mime_encoder() + * + * DESCRIPTION + * + * Set mime data transfer encoder. + */ +CURL_EXTERN CURLcode curl_mime_encoder(curl_mimepart *part, + const char *encoding); + +/* + * NAME curl_mime_data() + * + * DESCRIPTION + * + * Set mime part data source from memory data, + */ +CURL_EXTERN CURLcode curl_mime_data(curl_mimepart *part, + const char *data, size_t datasize); + +/* + * NAME curl_mime_filedata() + * + * DESCRIPTION + * + * Set mime part data source from named file. + */ +CURL_EXTERN CURLcode curl_mime_filedata(curl_mimepart *part, + const char *filename); + +/* + * NAME curl_mime_data_cb() + * + * DESCRIPTION + * + * Set mime part data source from callback function. + */ +CURL_EXTERN CURLcode curl_mime_data_cb(curl_mimepart *part, + curl_off_t datasize, + curl_read_callback readfunc, + curl_seek_callback seekfunc, + curl_free_callback freefunc, + void *arg); + +/* + * NAME curl_mime_subparts() + * + * DESCRIPTION + * + * Set mime part data source from subparts. + */ +CURL_EXTERN CURLcode curl_mime_subparts(curl_mimepart *part, + curl_mime *subparts); +/* + * NAME curl_mime_headers() + * + * DESCRIPTION + * + * Set mime part headers. + */ +CURL_EXTERN CURLcode curl_mime_headers(curl_mimepart *part, + struct curl_slist *headers, + int take_ownership); + +typedef enum { + CURLFORM_NOTHING, /********* the first one is unused ************/ + CURLFORM_COPYNAME, + CURLFORM_PTRNAME, + CURLFORM_NAMELENGTH, + CURLFORM_COPYCONTENTS, + CURLFORM_PTRCONTENTS, + CURLFORM_CONTENTSLENGTH, + CURLFORM_FILECONTENT, + CURLFORM_ARRAY, + CURLFORM_OBSOLETE, + CURLFORM_FILE, + + CURLFORM_BUFFER, + CURLFORM_BUFFERPTR, + CURLFORM_BUFFERLENGTH, + + CURLFORM_CONTENTTYPE, + CURLFORM_CONTENTHEADER, + CURLFORM_FILENAME, + CURLFORM_END, + CURLFORM_OBSOLETE2, + + CURLFORM_STREAM, + CURLFORM_CONTENTLEN, /* added in 7.46.0, provide a curl_off_t length */ + + CURLFORM_LASTENTRY /* the last unused */ +} CURLformoption; + +/* 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 will 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_global_sslset() + * + * DESCRIPTION + * + * When built with multiple SSL backends, curl_global_sslset() allows to + * choose one. This function can only be called once, and it must be called + * *before* curl_global_init(). + * + * The backend can be identified by the id (e.g. CURLSSLBACKEND_OPENSSL). The + * backend can also be specified via the name parameter (passing -1 as id). + * If both id and name are specified, the name will be ignored. If neither id + * nor name are specified, the function will fail with + * CURLSSLSET_UNKNOWN_BACKEND and set the "avail" pointer to the + * NULL-terminated list of available backends. + * + * Upon success, the function returns CURLSSLSET_OK. + * + * If the specified SSL backend is not available, the function returns + * CURLSSLSET_UNKNOWN_BACKEND and sets the "avail" pointer to a NULL-terminated + * list of available SSL backends. + * + * The SSL backend can be set only once. If it has already been set, a + * subsequent attempt to change it will result in a CURLSSLSET_TOO_LATE. + */ + +struct curl_ssl_backend { + curl_sslbackend id; + const char *name; +}; +typedef struct curl_ssl_backend curl_ssl_backend; + +typedef enum { + CURLSSLSET_OK = 0, + CURLSSLSET_UNKNOWN_BACKEND, + CURLSSLSET_TOO_LATE, + CURLSSLSET_NO_BACKENDS /* libcurl was built without any SSL support */ +} CURLsslset; + +CURL_EXTERN CURLsslset curl_global_sslset(curl_sslbackend id, const char *name, + const curl_ssl_backend ***avail); + +/* + * 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, GnuTLS, Schannel, NSS + and GSKit 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" */ +}; + +/* Information about the SSL library used and the respective internal SSL + handle, which can be used to obtain further information regarding the + connection. Asked for with CURLINFO_TLS_SSL_PTR or CURLINFO_TLS_SESSION. */ +struct curl_tlssessioninfo { + curl_sslbackend backend; + void *internals; +}; + +#define CURLINFO_STRING 0x100000 +#define CURLINFO_LONG 0x200000 +#define CURLINFO_DOUBLE 0x300000 +#define CURLINFO_SLIST 0x400000 +#define CURLINFO_PTR 0x400000 /* same as SLIST */ +#define CURLINFO_SOCKET 0x500000 +#define CURLINFO_OFF_T 0x600000 +#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_UPLOAD_T = CURLINFO_OFF_T + 7, + CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8, + CURLINFO_SIZE_DOWNLOAD_T = CURLINFO_OFF_T + 8, + CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9, + CURLINFO_SPEED_DOWNLOAD_T = CURLINFO_OFF_T + 9, + CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10, + CURLINFO_SPEED_UPLOAD_T = CURLINFO_OFF_T + 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_FILETIME_T = CURLINFO_OFF_T + 14, + CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15, + CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO_OFF_T + 15, + CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16, + CURLINFO_CONTENT_LENGTH_UPLOAD_T = CURLINFO_OFF_T + 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_PTR + 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, + CURLINFO_TLS_SESSION = CURLINFO_PTR + 43, + CURLINFO_ACTIVESOCKET = CURLINFO_SOCKET + 44, + CURLINFO_TLS_SSL_PTR = CURLINFO_PTR + 45, + CURLINFO_HTTP_VERSION = CURLINFO_LONG + 46, + CURLINFO_PROXY_SSL_VERIFYRESULT = CURLINFO_LONG + 47, + CURLINFO_PROTOCOL = CURLINFO_LONG + 48, + CURLINFO_SCHEME = CURLINFO_STRING + 49, + CURLINFO_TOTAL_TIME_T = CURLINFO_OFF_T + 50, + CURLINFO_NAMELOOKUP_TIME_T = CURLINFO_OFF_T + 51, + CURLINFO_CONNECT_TIME_T = CURLINFO_OFF_T + 52, + CURLINFO_PRETRANSFER_TIME_T = CURLINFO_OFF_T + 53, + CURLINFO_STARTTRANSFER_TIME_T = CURLINFO_OFF_T + 54, + CURLINFO_REDIRECT_TIME_T = CURLINFO_OFF_T + 55, + CURLINFO_APPCONNECT_TIME_T = CURLINFO_OFF_T + 56, + CURLINFO_RETRY_AFTER = CURLINFO_OFF_T + 57, + CURLINFO_EFFECTIVE_METHOD = CURLINFO_STRING + 58, + CURLINFO_PROXY_ERROR = CURLINFO_LONG + 59, + CURLINFO_REFERER = CURLINFO_STRING + 60, + + CURLINFO_LASTONE = 60 +} 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) /* no purpose since 7.57.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 +#define CURL_GLOBAL_ACK_EINTR (1<<2) + + +/***************************************************************************** + * 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_PSL, + 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 enum { + CURLSHE_OK, /* all is fine */ + CURLSHE_BAD_OPTION, /* 1 */ + CURLSHE_IN_USE, /* 2 */ + CURLSHE_INVALID, /* 3 */ + CURLSHE_NOMEM, /* 4 out of memory */ + CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */ + 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_FIFTH, + CURLVERSION_SIXTH, + CURLVERSION_SEVENTH, + CURLVERSION_EIGHTH, + CURLVERSION_NINTH, + CURLVERSION_TENTH, + 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_TENTH + +struct curl_version_info_data { + 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 */ + + /* These fields were added in CURLVERSION_FIFTH */ + unsigned int brotli_ver_num; /* Numeric Brotli version + (MAJOR << 24) | (MINOR << 12) | PATCH */ + const char *brotli_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_SIXTH */ + unsigned int nghttp2_ver_num; /* Numeric nghttp2 version + (MAJOR << 16) | (MINOR << 8) | PATCH */ + const char *nghttp2_version; /* human readable string. */ + const char *quic_version; /* human readable quic (+ HTTP/3) library + + version or NULL */ + + /* These fields were added in CURLVERSION_SEVENTH */ + const char *cainfo; /* the built-in default CURLOPT_CAINFO, might + be NULL */ + const char *capath; /* the built-in default CURLOPT_CAPATH, might + be NULL */ + + /* These fields were added in CURLVERSION_EIGHTH */ + unsigned int zstd_ver_num; /* Numeric Zstd version + (MAJOR << 24) | (MINOR << 12) | PATCH */ + const char *zstd_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_NINTH */ + const char *hyper_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_TENTH */ + const char *gsasl_version; /* human readable string. */ +}; +typedef struct curl_version_info_data curl_version_info_data; + +#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ +#define CURL_VERSION_KERBEROS4 (1<<1) /* Kerberos V4 auth is supported + (deprecated) */ +#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 is supported + (deprecated) */ +#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 is supported */ +#define CURL_VERSION_LARGEFILE (1<<9) /* Supports files larger than 2GB */ +#define CURL_VERSION_IDN (1<<10) /* Internationized Domain Names are + supported */ +#define CURL_VERSION_SSPI (1<<11) /* Built against Windows SSPI */ +#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 delegation to winbind helper + is supported */ +#define CURL_VERSION_HTTP2 (1<<16) /* HTTP2 support built-in */ +#define CURL_VERSION_GSSAPI (1<<17) /* Built against a GSS-API library */ +#define CURL_VERSION_KERBEROS5 (1<<18) /* Kerberos V5 auth is supported */ +#define CURL_VERSION_UNIX_SOCKETS (1<<19) /* Unix domain sockets support */ +#define CURL_VERSION_PSL (1<<20) /* Mozilla's Public Suffix List, used + for cookie domain verification */ +#define CURL_VERSION_HTTPS_PROXY (1<<21) /* HTTPS-proxy support built-in */ +#define CURL_VERSION_MULTI_SSL (1<<22) /* Multiple SSL backends available */ +#define CURL_VERSION_BROTLI (1<<23) /* Brotli features are present. */ +#define CURL_VERSION_ALTSVC (1<<24) /* Alt-Svc handling built-in */ +#define CURL_VERSION_HTTP3 (1<<25) /* HTTP3 support built-in */ +#define CURL_VERSION_ZSTD (1<<26) /* zstd features are present */ +#define CURL_VERSION_UNICODE (1<<27) /* Unicode support on Windows */ +#define CURL_VERSION_HSTS (1<<28) /* HSTS is supported */ +#define CURL_VERSION_GSASL (1<<29) /* libgsasl is supported */ + + /* + * 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" +#include "urlapi.h" +#include "options.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 /* CURLINC_CURL_H */ diff --git a/third_party/libcurl/uos/aarch64/include/curl/curlver.h b/third_party/libcurl/uos/aarch64/include/curl/curlver.h new file mode 100644 index 00000000..14d168e9 --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/curlver.h @@ -0,0 +1,77 @@ +#ifndef CURLINC_CURLVER_H +#define CURLINC_CURLVER_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2022, 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 https://curl.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 - 2022 Daniel Stenberg, ." + +/* This is the version number of the libcurl package from which this header + file origins: */ +#define LIBCURL_VERSION "7.82.0" + +/* The numeric version number is also available "in parts" by using these + defines: */ +#define LIBCURL_VERSION_MAJOR 7 +#define LIBCURL_VERSION_MINOR 82 +#define LIBCURL_VERSION_PATCH 0 + +/* This is the numeric version of the libcurl version number, meant for easier + parsing and comparisons 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. + + Note: This define is the full hex number and _does not_ use the + CURL_VERSION_BITS() macro since curl's own configure script greps for it + and needs it to contain the full number. +*/ +#define LIBCURL_VERSION_NUM 0x075200 + +/* + * 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 follows this template: + * + * "2007-11-23" + */ +#define LIBCURL_TIMESTAMP "2022-03-05" + +#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|(z)) +#define CURL_AT_LEAST_VERSION(x,y,z) \ + (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z)) + +#endif /* CURLINC_CURLVER_H */ diff --git a/third_party/libcurl/uos/aarch64/include/curl/easy.h b/third_party/libcurl/uos/aarch64/include/curl/easy.h new file mode 100644 index 00000000..2dbfb26b --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/easy.h @@ -0,0 +1,123 @@ +#ifndef CURLINC_EASY_H +#define CURLINC_EASY_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2020, 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 https://curl.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 + +/* Flag bits in the curl_blob struct: */ +#define CURL_BLOB_COPY 1 /* tell libcurl to copy the data */ +#define CURL_BLOB_NOCOPY 0 /* tell libcurl to NOT copy the data */ + +struct curl_blob { + void *data; + size_t len; + unsigned int flags; /* bit 0 is defined, the rest are reserved and should be + left zeroes */ +}; + +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); + + +/* + * NAME curl_easy_upkeep() + * + * DESCRIPTION + * + * Performs connection upkeep for the given session handle. + */ +CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/third_party/libcurl/uos/aarch64/include/curl/mprintf.h b/third_party/libcurl/uos/aarch64/include/curl/mprintf.h new file mode 100644 index 00000000..3549552d --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/mprintf.h @@ -0,0 +1,50 @@ +#ifndef CURLINC_MPRINTF_H +#define CURLINC_MPRINTF_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2020, 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 https://curl.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" /* for CURL_EXTERN */ + +#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 __cplusplus +} +#endif + +#endif /* CURLINC_MPRINTF_H */ diff --git a/third_party/libcurl/uos/aarch64/include/curl/multi.h b/third_party/libcurl/uos/aarch64/include/curl/multi.h new file mode 100644 index 00000000..91cd95d3 --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/multi.h @@ -0,0 +1,457 @@ +#ifndef CURLINC_MULTI_H +#define CURLINC_MULTI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2021, 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 https://curl.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 + +#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) +typedef struct Curl_multi CURLM; +#else +typedef void CURLM; +#endif + +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_ADDED_ALREADY, /* an easy handle already added to a multi handle was + attempted to get added - again */ + CURLM_RECURSIVE_API_CALL, /* an api function was called from inside a + callback */ + CURLM_WAKEUP_FAILURE, /* wakeup is unavailable or failed */ + CURLM_BAD_FUNCTION_ARGUMENT, /* function called with a bad parameter */ + CURLM_ABORTED_BY_CALLBACK, + 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 + +/* bitmask bits for CURLMOPT_PIPELINING */ +#define CURLPIPE_NOTHING 0L +#define CURLPIPE_HTTP1 1L +#define CURLPIPE_MULTIPLEX 2L + +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; + +/* Based on poll(2) structure and values. + * We don't use pollfd and POLL* constants explicitly + * to cover platforms without poll(). */ +#define CURL_WAIT_POLLIN 0x0001 +#define CURL_WAIT_POLLPRI 0x0002 +#define CURL_WAIT_POLLOUT 0x0004 + +struct curl_waitfd { + curl_socket_t fd; + short events; + short revents; /* not supported yet */ +}; + +/* + * 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_wait() + * + * Desc: Poll on all fds within a CURLM set as well as any + * additional fds passed to the function. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle, + struct curl_waitfd extra_fds[], + unsigned int extra_nfds, + int timeout_ms, + int *ret); + +/* + * Name: curl_multi_poll() + * + * Desc: Poll on all fds within a CURLM set as well as any + * additional fds passed to the function. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_poll(CURLM *multi_handle, + struct curl_waitfd extra_fds[], + unsigned int extra_nfds, + int timeout_ms, + int *ret); + +/* + * Name: curl_multi_wakeup() + * + * Desc: wakes up a sleeping curl_multi_poll call. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_wakeup(CURLM *multi_handle); + + /* + * 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 individual 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 information. 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 null-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); + +typedef enum { + /* This is the socket callback function pointer */ + CURLOPT(CURLMOPT_SOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 1), + + /* This is the argument passed to the socket callback */ + CURLOPT(CURLMOPT_SOCKETDATA, CURLOPTTYPE_OBJECTPOINT, 2), + + /* set to 1 to enable pipelining for this multi handle */ + CURLOPT(CURLMOPT_PIPELINING, CURLOPTTYPE_LONG, 3), + + /* This is the timer callback function pointer */ + CURLOPT(CURLMOPT_TIMERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 4), + + /* This is the argument passed to the timer callback */ + CURLOPT(CURLMOPT_TIMERDATA, CURLOPTTYPE_OBJECTPOINT, 5), + + /* maximum number of entries in the connection cache */ + CURLOPT(CURLMOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 6), + + /* maximum number of (pipelining) connections to one host */ + CURLOPT(CURLMOPT_MAX_HOST_CONNECTIONS, CURLOPTTYPE_LONG, 7), + + /* maximum number of requests in a pipeline */ + CURLOPT(CURLMOPT_MAX_PIPELINE_LENGTH, CURLOPTTYPE_LONG, 8), + + /* a connection with a content-length longer than this + will not be considered for pipelining */ + CURLOPT(CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 9), + + /* a connection with a chunk length longer than this + will not be considered for pipelining */ + CURLOPT(CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 10), + + /* a list of site names(+port) that are blocked from pipelining */ + CURLOPT(CURLMOPT_PIPELINING_SITE_BL, CURLOPTTYPE_OBJECTPOINT, 11), + + /* a list of server types that are blocked from pipelining */ + CURLOPT(CURLMOPT_PIPELINING_SERVER_BL, CURLOPTTYPE_OBJECTPOINT, 12), + + /* maximum number of open connections in total */ + CURLOPT(CURLMOPT_MAX_TOTAL_CONNECTIONS, CURLOPTTYPE_LONG, 13), + + /* This is the server push callback function pointer */ + CURLOPT(CURLMOPT_PUSHFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 14), + + /* This is the argument passed to the server push callback */ + CURLOPT(CURLMOPT_PUSHDATA, CURLOPTTYPE_OBJECTPOINT, 15), + + /* maximum number of concurrent streams to support on a connection */ + CURLOPT(CURLMOPT_MAX_CONCURRENT_STREAMS, CURLOPTTYPE_LONG, 16), + + 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); + + +/* + * Name: curl_push_callback + * + * Desc: This callback gets called when a new stream is being pushed by the + * server. It approves or denies the new stream. It can also decide + * to completely fail the connection. + * + * Returns: CURL_PUSH_OK, CURL_PUSH_DENY or CURL_PUSH_ERROROUT + */ +#define CURL_PUSH_OK 0 +#define CURL_PUSH_DENY 1 +#define CURL_PUSH_ERROROUT 2 /* added in 7.72.0 */ + +struct curl_pushheaders; /* forward declaration only */ + +CURL_EXTERN char *curl_pushheader_bynum(struct curl_pushheaders *h, + size_t num); +CURL_EXTERN char *curl_pushheader_byname(struct curl_pushheaders *h, + const char *name); + +typedef int (*curl_push_callback)(CURL *parent, + CURL *easy, + size_t num_headers, + struct curl_pushheaders *headers, + void *userp); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/third_party/libcurl/uos/aarch64/include/curl/options.h b/third_party/libcurl/uos/aarch64/include/curl/options.h new file mode 100644 index 00000000..14373b55 --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/options.h @@ -0,0 +1,68 @@ +#ifndef CURLINC_OPTIONS_H +#define CURLINC_OPTIONS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 2018 - 2020, 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 https://curl.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 + +typedef enum { + CURLOT_LONG, /* long (a range of values) */ + CURLOT_VALUES, /* (a defined set or bitmask) */ + CURLOT_OFF_T, /* curl_off_t (a range of values) */ + CURLOT_OBJECT, /* pointer (void *) */ + CURLOT_STRING, /* (char * to zero terminated buffer) */ + CURLOT_SLIST, /* (struct curl_slist *) */ + CURLOT_CBPTR, /* (void * passed as-is to a callback) */ + CURLOT_BLOB, /* blob (struct curl_blob *) */ + CURLOT_FUNCTION /* function pointer */ +} curl_easytype; + +/* Flag bits */ + +/* "alias" means it is provided for old programs to remain functional, + we prefer another name */ +#define CURLOT_FLAG_ALIAS (1<<0) + +/* The CURLOPTTYPE_* id ranges can still be used to figure out what type/size + to use for curl_easy_setopt() for the given id */ +struct curl_easyoption { + const char *name; + CURLoption id; + curl_easytype type; + unsigned int flags; +}; + +CURL_EXTERN const struct curl_easyoption * +curl_easy_option_by_name(const char *name); + +CURL_EXTERN const struct curl_easyoption * +curl_easy_option_by_id (CURLoption id); + +CURL_EXTERN const struct curl_easyoption * +curl_easy_option_next(const struct curl_easyoption *prev); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif +#endif /* CURLINC_OPTIONS_H */ diff --git a/third_party/libcurl/uos/aarch64/include/curl/stdcheaders.h b/third_party/libcurl/uos/aarch64/include/curl/stdcheaders.h new file mode 100644 index 00000000..60596c75 --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/stdcheaders.h @@ -0,0 +1,33 @@ +#ifndef CURLINC_STDCHEADERS_H +#define CURLINC_STDCHEADERS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2020, 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 https://curl.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 /* CURLINC_STDCHEADERS_H */ diff --git a/third_party/libcurl/uos/aarch64/include/curl/system.h b/third_party/libcurl/uos/aarch64/include/curl/system.h new file mode 100644 index 00000000..038ac0b1 --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/system.h @@ -0,0 +1,488 @@ +#ifndef CURLINC_SYSTEM_H +#define CURLINC_SYSTEM_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2022, 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 https://curl.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. + * + ***************************************************************************/ + +/* + * 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. + * + * curl_off_t + * ---------- + * + * 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. + * + */ + +#if defined(__DJGPP__) || defined(__GO32__) +# if defined(__DJGPP__) && (__DJGPP__ > 1) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__SALFORDC__) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__BORLANDC__) +# if (__BORLANDC__ < 0x520) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__TURBOC__) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__POCC__) +# if (__POCC__ < 280) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# elif defined(_MSC_VER) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__LCC__) +# if defined(__e2k__) /* MCST eLbrus C Compiler */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# else /* Local (or Little) C Compiler */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# endif + +#elif defined(__SYMBIAN32__) +# if defined(__EABI__) /* Treat all ARM compilers equally */ +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__CW32__) +# pragma longlong on +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__VC32__) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int + +#elif defined(__MWERKS__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(_WIN32_WCE) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__MINGW32__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_WS2TCPIP_H 1 + +#elif defined(__VMS) +# if defined(__VAX) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int + +#elif defined(__OS400__) +# if defined(__ILEC400__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# 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) +# elif defined(_LP64) +# 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_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_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_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# 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) +# elif defined(_LP64) +# 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_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_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_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(TPF) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__TINYC__) /* also known as tcc */ +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) /* Oracle Solaris Studio */ +# if !defined(__LP64) && (defined(__ILP32) || \ + defined(__i386) || \ + defined(__sparcv8) || \ + defined(__sparcv8plus)) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__LP64) || \ + defined(__amd64) || defined(__sparcv9) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# 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_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#elif defined(__xlc__) /* IBM xlc compiler */ +# if !defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# 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_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +/* ===================================== */ +/* KEEP MSVC THE PENULTIMATE ENTRY */ +/* ===================================== */ + +#elif defined(_MSC_VER) +# if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +/* ===================================== */ +/* KEEP GENERIC GCC THE LAST ENTRY */ +/* ===================================== */ + +#elif defined(__GNUC__) && !defined(_SCO_DS) +# if !defined(__LP64__) && \ + (defined(__ILP32__) || defined(__i386__) || defined(__hppa__) || \ + defined(__ppc__) || defined(__powerpc__) || defined(__arm__) || \ + defined(__sparc__) || defined(__mips__) || defined(__sh__) || \ + defined(__XTENSA__) || \ + (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 4) || \ + (defined(__LONG_MAX__) && __LONG_MAX__ == 2147483647L)) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__LP64__) || \ + defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__) || \ + defined(__e2k__) || \ + (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 8) || \ + (defined(__LONG_MAX__) && __LONG_MAX__ == 9223372036854775807L) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# 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_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#else +/* generic "safe guess" on old 32 bit style */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +#endif + +#ifdef _AIX +/* AIX needs */ +#define CURL_PULL_SYS_POLL_H +#endif + + +/* CURL_PULL_WS2TCPIP_H is defined above when inclusion of header file */ +/* ws2tcpip.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_WS2TCPIP_H +# include +# include +# include +#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 + +/* CURL_PULL_SYS_POLL_H is defined above when inclusion of header file */ +/* sys/poll.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_POLL_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 + +/* + * 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 + * curl_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 CURLINC_OFF_T_C_HLPR2(x) x +# define CURLINC_OFF_T_C_HLPR1(x) CURLINC_OFF_T_C_HLPR2(x) +# define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ + CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ + CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) +#else +# ifdef CURL_ISOCPP +# define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix +# else +# define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix +# endif +# define CURLINC_OFF_T_C_HLPR1(Val,Suffix) CURLINC_OFF_T_C_HLPR2(Val,Suffix) +# define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) +#endif + +#endif /* CURLINC_SYSTEM_H */ diff --git a/third_party/libcurl/uos/aarch64/include/curl/typecheck-gcc.h b/third_party/libcurl/uos/aarch64/include/curl/typecheck-gcc.h new file mode 100644 index 00000000..9e14d8a3 --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/typecheck-gcc.h @@ -0,0 +1,707 @@ +#ifndef CURLINC_TYPECHECK_GCC_H +#define CURLINC_TYPECHECK_GCC_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2021, 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 https://curl.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(curlcheck_sometype_option(_curl_opt)) + * if(!curlcheck_sometype(value)) + * _curl_easy_setopt_err_sometype(); + * block and define curlcheck_sometype_option, curlcheck_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(curlcheck_long_option(_curl_opt)) \ + if(!curlcheck_long(value)) \ + _curl_easy_setopt_err_long(); \ + if(curlcheck_off_t_option(_curl_opt)) \ + if(!curlcheck_off_t(value)) \ + _curl_easy_setopt_err_curl_off_t(); \ + if(curlcheck_string_option(_curl_opt)) \ + if(!curlcheck_string(value)) \ + _curl_easy_setopt_err_string(); \ + if(curlcheck_write_cb_option(_curl_opt)) \ + if(!curlcheck_write_cb(value)) \ + _curl_easy_setopt_err_write_callback(); \ + if((_curl_opt) == CURLOPT_RESOLVER_START_FUNCTION) \ + if(!curlcheck_resolver_start_callback(value)) \ + _curl_easy_setopt_err_resolver_start_callback(); \ + if((_curl_opt) == CURLOPT_READFUNCTION) \ + if(!curlcheck_read_cb(value)) \ + _curl_easy_setopt_err_read_cb(); \ + if((_curl_opt) == CURLOPT_IOCTLFUNCTION) \ + if(!curlcheck_ioctl_cb(value)) \ + _curl_easy_setopt_err_ioctl_cb(); \ + if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \ + if(!curlcheck_sockopt_cb(value)) \ + _curl_easy_setopt_err_sockopt_cb(); \ + if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \ + if(!curlcheck_opensocket_cb(value)) \ + _curl_easy_setopt_err_opensocket_cb(); \ + if((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \ + if(!curlcheck_progress_cb(value)) \ + _curl_easy_setopt_err_progress_cb(); \ + if((_curl_opt) == CURLOPT_DEBUGFUNCTION) \ + if(!curlcheck_debug_cb(value)) \ + _curl_easy_setopt_err_debug_cb(); \ + if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \ + if(!curlcheck_ssl_ctx_cb(value)) \ + _curl_easy_setopt_err_ssl_ctx_cb(); \ + if(curlcheck_conv_cb_option(_curl_opt)) \ + if(!curlcheck_conv_cb(value)) \ + _curl_easy_setopt_err_conv_cb(); \ + if((_curl_opt) == CURLOPT_SEEKFUNCTION) \ + if(!curlcheck_seek_cb(value)) \ + _curl_easy_setopt_err_seek_cb(); \ + if(curlcheck_cb_data_option(_curl_opt)) \ + if(!curlcheck_cb_data(value)) \ + _curl_easy_setopt_err_cb_data(); \ + if((_curl_opt) == CURLOPT_ERRORBUFFER) \ + if(!curlcheck_error_buffer(value)) \ + _curl_easy_setopt_err_error_buffer(); \ + if((_curl_opt) == CURLOPT_STDERR) \ + if(!curlcheck_FILE(value)) \ + _curl_easy_setopt_err_FILE(); \ + if(curlcheck_postfields_option(_curl_opt)) \ + if(!curlcheck_postfields(value)) \ + _curl_easy_setopt_err_postfields(); \ + if((_curl_opt) == CURLOPT_HTTPPOST) \ + if(!curlcheck_arr((value), struct curl_httppost)) \ + _curl_easy_setopt_err_curl_httpost(); \ + if((_curl_opt) == CURLOPT_MIMEPOST) \ + if(!curlcheck_ptr((value), curl_mime)) \ + _curl_easy_setopt_err_curl_mimepost(); \ + if(curlcheck_slist_option(_curl_opt)) \ + if(!curlcheck_arr((value), struct curl_slist)) \ + _curl_easy_setopt_err_curl_slist(); \ + if((_curl_opt) == CURLOPT_SHARE) \ + if(!curlcheck_ptr((value), CURLSH)) \ + _curl_easy_setopt_err_CURLSH(); \ + } \ + curl_easy_setopt(handle, _curl_opt, value); \ + }) + +/* wraps curl_easy_getinfo() with typechecking */ +#define curl_easy_getinfo(handle, info, arg) \ + __extension__({ \ + __typeof__(info) _curl_info = info; \ + if(__builtin_constant_p(_curl_info)) { \ + if(curlcheck_string_info(_curl_info)) \ + if(!curlcheck_arr((arg), char *)) \ + _curl_easy_getinfo_err_string(); \ + if(curlcheck_long_info(_curl_info)) \ + if(!curlcheck_arr((arg), long)) \ + _curl_easy_getinfo_err_long(); \ + if(curlcheck_double_info(_curl_info)) \ + if(!curlcheck_arr((arg), double)) \ + _curl_easy_getinfo_err_double(); \ + if(curlcheck_slist_info(_curl_info)) \ + if(!curlcheck_arr((arg), struct curl_slist *)) \ + _curl_easy_getinfo_err_curl_slist(); \ + if(curlcheck_tlssessioninfo_info(_curl_info)) \ + if(!curlcheck_arr((arg), struct curl_tlssessioninfo *)) \ + _curl_easy_getinfo_err_curl_tlssesssioninfo(); \ + if(curlcheck_certinfo_info(_curl_info)) \ + if(!curlcheck_arr((arg), struct curl_certinfo *)) \ + _curl_easy_getinfo_err_curl_certinfo(); \ + if(curlcheck_socket_info(_curl_info)) \ + if(!curlcheck_arr((arg), curl_socket_t)) \ + _curl_easy_getinfo_err_curl_socket(); \ + if(curlcheck_off_t_info(_curl_info)) \ + if(!curlcheck_arr((arg), curl_off_t)) \ + _curl_easy_getinfo_err_curl_off_t(); \ + } \ + curl_easy_getinfo(handle, _curl_info, arg); \ + }) + +/* + * 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 CURLWARNING(id, message) \ + static void __attribute__((__warning__(message))) \ + __attribute__((__unused__)) __attribute__((__noinline__)) \ + id(void) { __asm__(""); } + +CURLWARNING(_curl_easy_setopt_err_long, + "curl_easy_setopt expects a long argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_off_t, + "curl_easy_setopt expects a curl_off_t argument for this option") +CURLWARNING(_curl_easy_setopt_err_string, + "curl_easy_setopt expects a " + "string ('char *' or char[]) argument for this option" + ) +CURLWARNING(_curl_easy_setopt_err_write_callback, + "curl_easy_setopt expects a curl_write_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_resolver_start_callback, + "curl_easy_setopt expects a " + "curl_resolver_start_callback argument for this option" + ) +CURLWARNING(_curl_easy_setopt_err_read_cb, + "curl_easy_setopt expects a curl_read_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_ioctl_cb, + "curl_easy_setopt expects a curl_ioctl_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_sockopt_cb, + "curl_easy_setopt expects a curl_sockopt_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_opensocket_cb, + "curl_easy_setopt expects a " + "curl_opensocket_callback argument for this option" + ) +CURLWARNING(_curl_easy_setopt_err_progress_cb, + "curl_easy_setopt expects a curl_progress_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_debug_cb, + "curl_easy_setopt expects a curl_debug_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_ssl_ctx_cb, + "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_conv_cb, + "curl_easy_setopt expects a curl_conv_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_seek_cb, + "curl_easy_setopt expects a curl_seek_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_cb_data, + "curl_easy_setopt expects a " + "private data pointer as argument for this option") +CURLWARNING(_curl_easy_setopt_err_error_buffer, + "curl_easy_setopt expects a " + "char buffer of CURL_ERROR_SIZE as argument for this option") +CURLWARNING(_curl_easy_setopt_err_FILE, + "curl_easy_setopt expects a 'FILE *' argument for this option") +CURLWARNING(_curl_easy_setopt_err_postfields, + "curl_easy_setopt expects a 'void *' or 'char *' argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_httpost, + "curl_easy_setopt expects a 'struct curl_httppost *' " + "argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_mimepost, + "curl_easy_setopt expects a 'curl_mime *' " + "argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_slist, + "curl_easy_setopt expects a 'struct curl_slist *' argument for this option") +CURLWARNING(_curl_easy_setopt_err_CURLSH, + "curl_easy_setopt expects a CURLSH* argument for this option") + +CURLWARNING(_curl_easy_getinfo_err_string, + "curl_easy_getinfo expects a pointer to 'char *' for this info") +CURLWARNING(_curl_easy_getinfo_err_long, + "curl_easy_getinfo expects a pointer to long for this info") +CURLWARNING(_curl_easy_getinfo_err_double, + "curl_easy_getinfo expects a pointer to double for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_slist, + "curl_easy_getinfo expects a pointer to 'struct curl_slist *' for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_tlssesssioninfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_tlssessioninfo *' for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_certinfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_certinfo *' for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_socket, + "curl_easy_getinfo expects a pointer to curl_socket_t for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_off_t, + "curl_easy_getinfo expects a pointer to curl_off_t 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 curlcheck_long_option(option) \ + (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT) + +#define curlcheck_off_t_option(option) \ + (((option) > CURLOPTTYPE_OFF_T) && ((option) < CURLOPTTYPE_BLOB)) + +/* evaluates to true if option takes a char* argument */ +#define curlcheck_string_option(option) \ + ((option) == CURLOPT_ABSTRACT_UNIX_SOCKET || \ + (option) == CURLOPT_ACCEPT_ENCODING || \ + (option) == CURLOPT_ALTSVC || \ + (option) == CURLOPT_CAINFO || \ + (option) == CURLOPT_CAPATH || \ + (option) == CURLOPT_COOKIE || \ + (option) == CURLOPT_COOKIEFILE || \ + (option) == CURLOPT_COOKIEJAR || \ + (option) == CURLOPT_COOKIELIST || \ + (option) == CURLOPT_CRLFILE || \ + (option) == CURLOPT_CUSTOMREQUEST || \ + (option) == CURLOPT_DEFAULT_PROTOCOL || \ + (option) == CURLOPT_DNS_INTERFACE || \ + (option) == CURLOPT_DNS_LOCAL_IP4 || \ + (option) == CURLOPT_DNS_LOCAL_IP6 || \ + (option) == CURLOPT_DNS_SERVERS || \ + (option) == CURLOPT_DOH_URL || \ + (option) == CURLOPT_EGDSOCKET || \ + (option) == CURLOPT_FTPPORT || \ + (option) == CURLOPT_FTP_ACCOUNT || \ + (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ + (option) == CURLOPT_HSTS || \ + (option) == CURLOPT_INTERFACE || \ + (option) == CURLOPT_ISSUERCERT || \ + (option) == CURLOPT_KEYPASSWD || \ + (option) == CURLOPT_KRBLEVEL || \ + (option) == CURLOPT_LOGIN_OPTIONS || \ + (option) == CURLOPT_MAIL_AUTH || \ + (option) == CURLOPT_MAIL_FROM || \ + (option) == CURLOPT_NETRC_FILE || \ + (option) == CURLOPT_NOPROXY || \ + (option) == CURLOPT_PASSWORD || \ + (option) == CURLOPT_PINNEDPUBLICKEY || \ + (option) == CURLOPT_PRE_PROXY || \ + (option) == CURLOPT_PROXY || \ + (option) == CURLOPT_PROXYPASSWORD || \ + (option) == CURLOPT_PROXYUSERNAME || \ + (option) == CURLOPT_PROXYUSERPWD || \ + (option) == CURLOPT_PROXY_CAINFO || \ + (option) == CURLOPT_PROXY_CAPATH || \ + (option) == CURLOPT_PROXY_CRLFILE || \ + (option) == CURLOPT_PROXY_ISSUERCERT || \ + (option) == CURLOPT_PROXY_KEYPASSWD || \ + (option) == CURLOPT_PROXY_PINNEDPUBLICKEY || \ + (option) == CURLOPT_PROXY_SERVICE_NAME || \ + (option) == CURLOPT_PROXY_SSLCERT || \ + (option) == CURLOPT_PROXY_SSLCERTTYPE || \ + (option) == CURLOPT_PROXY_SSLKEY || \ + (option) == CURLOPT_PROXY_SSLKEYTYPE || \ + (option) == CURLOPT_PROXY_SSL_CIPHER_LIST || \ + (option) == CURLOPT_PROXY_TLS13_CIPHERS || \ + (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD || \ + (option) == CURLOPT_PROXY_TLSAUTH_TYPE || \ + (option) == CURLOPT_PROXY_TLSAUTH_USERNAME || \ + (option) == CURLOPT_RANDOM_FILE || \ + (option) == CURLOPT_RANGE || \ + (option) == CURLOPT_REFERER || \ + (option) == CURLOPT_REQUEST_TARGET || \ + (option) == CURLOPT_RTSP_SESSION_ID || \ + (option) == CURLOPT_RTSP_STREAM_URI || \ + (option) == CURLOPT_RTSP_TRANSPORT || \ + (option) == CURLOPT_SASL_AUTHZID || \ + (option) == CURLOPT_SERVICE_NAME || \ + (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 || \ + (option) == CURLOPT_SSH_KNOWNHOSTS || \ + (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \ + (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \ + (option) == CURLOPT_SSLCERT || \ + (option) == CURLOPT_SSLCERTTYPE || \ + (option) == CURLOPT_SSLENGINE || \ + (option) == CURLOPT_SSLKEY || \ + (option) == CURLOPT_SSLKEYTYPE || \ + (option) == CURLOPT_SSL_CIPHER_LIST || \ + (option) == CURLOPT_TLS13_CIPHERS || \ + (option) == CURLOPT_TLSAUTH_PASSWORD || \ + (option) == CURLOPT_TLSAUTH_TYPE || \ + (option) == CURLOPT_TLSAUTH_USERNAME || \ + (option) == CURLOPT_UNIX_SOCKET_PATH || \ + (option) == CURLOPT_URL || \ + (option) == CURLOPT_USERAGENT || \ + (option) == CURLOPT_USERNAME || \ + (option) == CURLOPT_AWS_SIGV4 || \ + (option) == CURLOPT_USERPWD || \ + (option) == CURLOPT_XOAUTH2_BEARER || \ + (option) == CURLOPT_SSL_EC_CURVES || \ + 0) + +/* evaluates to true if option takes a curl_write_callback argument */ +#define curlcheck_write_cb_option(option) \ + ((option) == CURLOPT_HEADERFUNCTION || \ + (option) == CURLOPT_WRITEFUNCTION) + +/* evaluates to true if option takes a curl_conv_callback argument */ +#define curlcheck_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 curlcheck_cb_data_option(option) \ + ((option) == CURLOPT_CHUNK_DATA || \ + (option) == CURLOPT_CLOSESOCKETDATA || \ + (option) == CURLOPT_DEBUGDATA || \ + (option) == CURLOPT_FNMATCH_DATA || \ + (option) == CURLOPT_HEADERDATA || \ + (option) == CURLOPT_HSTSREADDATA || \ + (option) == CURLOPT_HSTSWRITEDATA || \ + (option) == CURLOPT_INTERLEAVEDATA || \ + (option) == CURLOPT_IOCTLDATA || \ + (option) == CURLOPT_OPENSOCKETDATA || \ + (option) == CURLOPT_PREREQDATA || \ + (option) == CURLOPT_PROGRESSDATA || \ + (option) == CURLOPT_READDATA || \ + (option) == CURLOPT_SEEKDATA || \ + (option) == CURLOPT_SOCKOPTDATA || \ + (option) == CURLOPT_SSH_KEYDATA || \ + (option) == CURLOPT_SSL_CTX_DATA || \ + (option) == CURLOPT_WRITEDATA || \ + (option) == CURLOPT_RESOLVER_START_DATA || \ + (option) == CURLOPT_TRAILERDATA || \ + 0) + +/* evaluates to true if option takes a POST data argument (void* or char*) */ +#define curlcheck_postfields_option(option) \ + ((option) == CURLOPT_POSTFIELDS || \ + (option) == CURLOPT_COPYPOSTFIELDS || \ + 0) + +/* evaluates to true if option takes a struct curl_slist * argument */ +#define curlcheck_slist_option(option) \ + ((option) == CURLOPT_HTTP200ALIASES || \ + (option) == CURLOPT_HTTPHEADER || \ + (option) == CURLOPT_MAIL_RCPT || \ + (option) == CURLOPT_POSTQUOTE || \ + (option) == CURLOPT_PREQUOTE || \ + (option) == CURLOPT_PROXYHEADER || \ + (option) == CURLOPT_QUOTE || \ + (option) == CURLOPT_RESOLVE || \ + (option) == CURLOPT_TELNETOPTIONS || \ + (option) == CURLOPT_CONNECT_TO || \ + 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 curlcheck_string_info(info) \ + (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG && \ + (info) != CURLINFO_PRIVATE) + +/* evaluates to true if info expects a pointer to long argument */ +#define curlcheck_long_info(info) \ + (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE) + +/* evaluates to true if info expects a pointer to double argument */ +#define curlcheck_double_info(info) \ + (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST) + +/* true if info expects a pointer to struct curl_slist * argument */ +#define curlcheck_slist_info(info) \ + (((info) == CURLINFO_SSL_ENGINES) || ((info) == CURLINFO_COOKIELIST)) + +/* true if info expects a pointer to struct curl_tlssessioninfo * argument */ +#define curlcheck_tlssessioninfo_info(info) \ + (((info) == CURLINFO_TLS_SSL_PTR) || ((info) == CURLINFO_TLS_SESSION)) + +/* true if info expects a pointer to struct curl_certinfo * argument */ +#define curlcheck_certinfo_info(info) ((info) == CURLINFO_CERTINFO) + +/* true if info expects a pointer to struct curl_socket_t argument */ +#define curlcheck_socket_info(info) \ + (CURLINFO_SOCKET < (info) && (info) < CURLINFO_OFF_T) + +/* true if info expects a pointer to curl_off_t argument */ +#define curlcheck_off_t_info(info) \ + (CURLINFO_OFF_T < (info)) + + +/* typecheck helpers -- check whether given expression has requested type*/ + +/* For pointers, you can use the curlcheck_ptr/curlcheck_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 if expr is a pointer */ +#define curlcheck_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 curlcheck_NULL(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL))) + +/* evaluates to true if expr is type*, const type* or NULL */ +#define curlcheck_ptr(expr, type) \ + (curlcheck_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 curlcheck_arr(expr, type) \ + (curlcheck_ptr((expr), type) || \ + __builtin_types_compatible_p(__typeof__(expr), type [])) + +/* evaluates to true if expr is a string */ +#define curlcheck_string(expr) \ + (curlcheck_arr((expr), char) || \ + curlcheck_arr((expr), signed char) || \ + curlcheck_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 curlcheck_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 curlcheck_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 curlcheck_error_buffer(expr) \ + (curlcheck_NULL(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 curlcheck_cb_data(expr) \ + (curlcheck_ptr((expr), void) || \ + curlcheck_ptr((expr), FILE)) +#else /* be less strict */ +#define curlcheck_cb_data(expr) \ + curlcheck_any_ptr(expr) +#endif + +/* evaluates to true if expr is of type FILE* */ +#define curlcheck_FILE(expr) \ + (curlcheck_NULL(expr) || \ + (__builtin_types_compatible_p(__typeof__(expr), FILE *))) + +/* evaluates to true if expr can be passed as POST data (void* or char*) */ +#define curlcheck_postfields(expr) \ + (curlcheck_ptr((expr), void) || \ + curlcheck_arr((expr), char) || \ + curlcheck_arr((expr), unsigned char)) + +/* helper: __builtin_types_compatible_p distinguishes between functions and + * function pointers, hide it */ +#define curlcheck_cb_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_resolver_start_callback */ +#define curlcheck_resolver_start_callback(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_resolver_start_callback)) + +/* evaluates to true if expr is of type curl_read_callback or "similar" */ +#define curlcheck_read_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), __typeof__(fread) *) || \ + curlcheck_cb_compatible((expr), curl_read_callback) || \ + curlcheck_cb_compatible((expr), _curl_read_callback1) || \ + curlcheck_cb_compatible((expr), _curl_read_callback2) || \ + curlcheck_cb_compatible((expr), _curl_read_callback3) || \ + curlcheck_cb_compatible((expr), _curl_read_callback4) || \ + curlcheck_cb_compatible((expr), _curl_read_callback5) || \ + curlcheck_cb_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 curlcheck_write_cb(expr) \ + (curlcheck_read_cb(expr) || \ + curlcheck_cb_compatible((expr), __typeof__(fwrite) *) || \ + curlcheck_cb_compatible((expr), curl_write_callback) || \ + curlcheck_cb_compatible((expr), _curl_write_callback1) || \ + curlcheck_cb_compatible((expr), _curl_write_callback2) || \ + curlcheck_cb_compatible((expr), _curl_write_callback3) || \ + curlcheck_cb_compatible((expr), _curl_write_callback4) || \ + curlcheck_cb_compatible((expr), _curl_write_callback5) || \ + curlcheck_cb_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 curlcheck_ioctl_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_ioctl_callback) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback1) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback2) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback3) || \ + curlcheck_cb_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 curlcheck_sockopt_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_sockopt_callback) || \ + curlcheck_cb_compatible((expr), _curl_sockopt_callback1) || \ + curlcheck_cb_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 curlcheck_opensocket_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_opensocket_callback) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback1) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback2) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback3) || \ + curlcheck_cb_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 curlcheck_progress_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_progress_callback) || \ + curlcheck_cb_compatible((expr), _curl_progress_callback1) || \ + curlcheck_cb_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 curlcheck_debug_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_debug_callback) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback1) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback2) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback3) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback4) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback5) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback6) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback7) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback8)) +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 *); +typedef int (*_curl_debug_callback5) (CURL *, + curl_infotype, unsigned char *, size_t, void *); +typedef int (*_curl_debug_callback6) (CURL *, + curl_infotype, unsigned char *, size_t, const void *); +typedef int (*_curl_debug_callback7) (CURL *, + curl_infotype, const unsigned char *, size_t, void *); +typedef int (*_curl_debug_callback8) (CURL *, + curl_infotype, const unsigned 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 curlcheck_ssl_ctx_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_ssl_ctx_callback) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback1) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback2) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback3) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback4) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback5) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback6) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback7) || \ + curlcheck_cb_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 curlcheck_conv_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_conv_callback) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback1) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback2) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback3) || \ + curlcheck_cb_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 curlcheck_seek_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_seek_callback) || \ + curlcheck_cb_compatible((expr), _curl_seek_callback1) || \ + curlcheck_cb_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 /* CURLINC_TYPECHECK_GCC_H */ diff --git a/third_party/libcurl/uos/aarch64/include/curl/urlapi.h b/third_party/libcurl/uos/aarch64/include/curl/urlapi.h new file mode 100644 index 00000000..a475f91b --- /dev/null +++ b/third_party/libcurl/uos/aarch64/include/curl/urlapi.h @@ -0,0 +1,145 @@ +#ifndef CURLINC_URLAPI_H +#define CURLINC_URLAPI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 2018 - 2021, 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 https://curl.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 "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* the error codes for the URL API */ +typedef enum { + CURLUE_OK, + CURLUE_BAD_HANDLE, /* 1 */ + CURLUE_BAD_PARTPOINTER, /* 2 */ + CURLUE_MALFORMED_INPUT, /* 3 */ + CURLUE_BAD_PORT_NUMBER, /* 4 */ + CURLUE_UNSUPPORTED_SCHEME, /* 5 */ + CURLUE_URLDECODE, /* 6 */ + CURLUE_OUT_OF_MEMORY, /* 7 */ + CURLUE_USER_NOT_ALLOWED, /* 8 */ + CURLUE_UNKNOWN_PART, /* 9 */ + CURLUE_NO_SCHEME, /* 10 */ + CURLUE_NO_USER, /* 11 */ + CURLUE_NO_PASSWORD, /* 12 */ + CURLUE_NO_OPTIONS, /* 13 */ + CURLUE_NO_HOST, /* 14 */ + CURLUE_NO_PORT, /* 15 */ + CURLUE_NO_QUERY, /* 16 */ + CURLUE_NO_FRAGMENT, /* 17 */ + CURLUE_NO_ZONEID, /* 18 */ + CURLUE_BAD_FILE_URL, /* 19 */ + CURLUE_BAD_FRAGMENT, /* 20 */ + CURLUE_BAD_HOSTNAME, /* 21 */ + CURLUE_BAD_IPV6, /* 22 */ + CURLUE_BAD_LOGIN, /* 23 */ + CURLUE_BAD_PASSWORD, /* 24 */ + CURLUE_BAD_PATH, /* 25 */ + CURLUE_BAD_QUERY, /* 26 */ + CURLUE_BAD_SCHEME, /* 27 */ + CURLUE_BAD_SLASHES, /* 28 */ + CURLUE_BAD_USER, /* 29 */ + CURLUE_LAST +} CURLUcode; + +typedef enum { + CURLUPART_URL, + CURLUPART_SCHEME, + CURLUPART_USER, + CURLUPART_PASSWORD, + CURLUPART_OPTIONS, + CURLUPART_HOST, + CURLUPART_PORT, + CURLUPART_PATH, + CURLUPART_QUERY, + CURLUPART_FRAGMENT, + CURLUPART_ZONEID /* added in 7.65.0 */ +} CURLUPart; + +#define CURLU_DEFAULT_PORT (1<<0) /* return default port number */ +#define CURLU_NO_DEFAULT_PORT (1<<1) /* act as if no port number was set, + if the port number matches the + default for the scheme */ +#define CURLU_DEFAULT_SCHEME (1<<2) /* return default scheme if + missing */ +#define CURLU_NON_SUPPORT_SCHEME (1<<3) /* allow non-supported scheme */ +#define CURLU_PATH_AS_IS (1<<4) /* leave dot sequences */ +#define CURLU_DISALLOW_USER (1<<5) /* no user+password allowed */ +#define CURLU_URLDECODE (1<<6) /* URL decode on get */ +#define CURLU_URLENCODE (1<<7) /* URL encode on set */ +#define CURLU_APPENDQUERY (1<<8) /* append a form style part */ +#define CURLU_GUESS_SCHEME (1<<9) /* legacy curl-style guessing */ +#define CURLU_NO_AUTHORITY (1<<10) /* Allow empty authority when the + scheme is unknown. */ +#define CURLU_ALLOW_SPACE (1<<11) /* Allow spaces in the URL */ + +typedef struct Curl_URL CURLU; + +/* + * curl_url() creates a new CURLU handle and returns a pointer to it. + * Must be freed with curl_url_cleanup(). + */ +CURL_EXTERN CURLU *curl_url(void); + +/* + * curl_url_cleanup() frees the CURLU handle and related resources used for + * the URL parsing. It will not free strings previously returned with the URL + * API. + */ +CURL_EXTERN void curl_url_cleanup(CURLU *handle); + +/* + * curl_url_dup() duplicates a CURLU handle and returns a new copy. The new + * handle must also be freed with curl_url_cleanup(). + */ +CURL_EXTERN CURLU *curl_url_dup(CURLU *in); + +/* + * curl_url_get() extracts a specific part of the URL from a CURLU + * handle. Returns error code. The returned pointer MUST be freed with + * curl_free() afterwards. + */ +CURL_EXTERN CURLUcode curl_url_get(CURLU *handle, CURLUPart what, + char **part, unsigned int flags); + +/* + * curl_url_set() sets a specific part of the URL in a CURLU handle. Returns + * error code. The passed in string will be copied. Passing a NULL instead of + * a part string, clears that part. + */ +CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what, + const char *part, unsigned int flags); + +/* + * curl_url_strerror() turns a CURLUcode value into the equivalent human + * readable error string. This is useful for printing meaningful error + * messages. + */ +CURL_EXTERN const char *curl_url_strerror(CURLUcode); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif /* CURLINC_URLAPI_H */ diff --git a/third_party/libcurl/uos/aarch64/lib/libcurl.a b/third_party/libcurl/uos/aarch64/lib/libcurl.a new file mode 100644 index 0000000000000000000000000000000000000000..c56f77ed7639af50fa8b00856dd2dde01352b4c5 GIT binary patch literal 941078 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

3$M;xF=@k&!F-yTtx5`3?5t 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 z zV)vC#jgQ_s=J?yC@4izyHu|_;b?C)ca8dE@J7r^&ihS+u#4_MVj>@Efd@Vwb?o1ag2XlyR1mtWoU;Tv&Y(s(ism@{`TvNXz52d zMp{d-`*%cfC(PBjj$)ET594ogGtycG2V!=Iw+K0>k@mh>`TzR8Z-t0Q%Zd}F`7Ps- za8}PF;VU!XT+1Ixz9j?xwG8;b1I|5blf|SV?s+_if5aDg_#wep3$Eqw?*!MqM5YV^ zdk_Cc((|80{(|tBG6?L`4DvaUqdrBLRO4aFBhJ)&B>sX7`0NaLMF#xK8F22U8Y$jX z2AqTVk>sDtfPX6k-j@MCmI41k2K=WP@Ly!WN5k$T=|3R@{<#czNe2AZ4EQ}6@cT31 zf0P05&VcXFfOFz|r1bvh4EPT-;6DRSzdbICT*r*};*WXnu$8?@yY*ALcJ>`Z{OXC> z*||2^QN5wHu_aMgZTs66uB|oQaeLFyyryN1z2v)rLvJOL5&t^cS{jEQ+gAq-`5JUl zC7?#G{dS4Q_HwK7T6GJ$NW(#>*4|RPZaBz+!%$pid#Q;^`5k2F(ilPdC_(1ksI~RU z+I6PeVt)sw-9}{WD4Sc^tsIJe=#@%bRo8B4?`UbN9v0Txw3?lC8;l+A#^jm~dq=IS z`MYG*t+pF);h}dtTi3R=-`xrcC(*4PZ9^)g-{Y)H)@)D%UiM0-^S0(lZ<3l6n!U4$ zTG5OdjYO@nyLP?3!D|{C8>!B<84oAknx%(qLk<`;Uz|xi7er zZ;xW2uqJI84nCOuNl|D>Z{vT})eU%BQc~UCj!~sJnaSsBaRn^~MRIXH>K%6-c#+@} zfxCNo+1KR3g&!ARZDI4?D)*O!a(|zkuYtUa#|3A+?w;UQ2Y1WA_BScdK8PN>ZAAtN8aVnmae0wOYzWz5l@@~GbaPX<3J5O=JRiAo!R_EdBPxXSUo+_`u&#Ab|w|YDWg}>9| zQT$QCncm+KS)MSbXAae~&)%8|KVE9Qienzi9OSWmVSE3g$D@9Xg;R4VkK(U7JXn)U zAIAju?cbjP$M3?JL-p6Le|EOTHD1N@1o!oyEV%NV6W-9{QT)aXJjEW*OxTIXEgp~J z6%J2mB<-L39K6uM>plKT;cxZ$71!UXWqMuyJr4gghku{ozWonnz~69qKI`zDaq#I5 zo;%9ksGV0zdDh=|)%;Q%zjb2{>OaHbxy8Xh=ipm1;Ku~lcvF(UZwRjODz3l#`v0=` zE#OsE*Sd4>orI8$7)gK#6m}pWL`1*%A7S7-3_R1o-#74K241WiEy{VZfj?p3w7JOjw8ljb{2t-8 zN8_Rg!JjesnEKyu;Fs7etp8^m{H5NLiKN0`@E(b_XUcEZha)vEa>jHR*%}uj79KjkC*+Z=4xEz+^6wMjXTTBGL1X=zv$qG*5G62e>pdR@iO_3rac!Iaj`w|Ia}kRx8piqL5+*v1fOQ` zF~hBJ@JZHuDjj?TuQvFY^}s5FkD2au8h56P*u_NteY!n*(h;uUO-8t8x-=WO+1{Pf zxbPpX^ZywKf5Fchd`$i$dr;f9{>^se76Tt)lUV;NG%n#*ias?i=_2?t2Ys`aGv=Td ze67ZrA1*b*eZqy$4i`SMAHT>c-!rlwzsM>0Ge)?ke)c)SP1N$g>Ihfx{VseC8+^?C z)2wl4{yAmvF~4(r=#O*ihigUT%FwvPceKuLBQ-AZ6+Fw}W7dZS4nEnMPoaa4;L{8~ zrryE^&h_MS&2{j)=zV`D}3T5xm~uGeLyGeUF3Bex0A29DD?S z(cojoccM0eFkSi^{0lYCbTQL?y2hR9F5kAYW>r{~X@}rxT2ATj2%fF+`yKQ*YP{Zo zOF7-|z|Uy8u`#fYW;d}IVB{5zi zzsL~;Mz`6A!=rjfclH8&FfQ>Y_o;X%Zi7s9Hydx`g_D-!Zp3tT+)kOS{lD+{aDVj7P(~o||zocJRVOw7GLiQW=_bZ!SRvAwJ>_$4%j{a}dm4wIf(h(iY z_URy@ceO(|nibYl$3Lh4OUGo5%?Wf|qdS~>J*|z%zDn8I6UN#kUwkc2g<)_CTB4l0 z7KeLAUzQjpGYyAlK zZtxfX8h$VAa9?TCr*+_%w@p6BG2fl*d#KlQ_wBZIdkj46 zy{$R7K5i$|L$FT~7h)xIGO|U#e779WeKXarPqA0Hy~d^g&QGtj^9S|sgZ^W~)vlFD zgB8$og!)ImZ8^VtLlAOtuPEZ5PExHch(F&E=U&=OSBAB!fAEvwP^{BHct@|n@9Ug5 zZO=t-d7uz+8nE*y!dyOQNVecHpS_P5Y-Kq|;cpAxy*> z^JJ;JX3TYM@x@#2}tLpdMHt? zoF~tBZ9ZR)0)Oh);)`@E)^HdNrx=-J1E9I+@~(xig}uW0l{o}u19(Q6#4HM z!aZ^Y^kMla_j9 z9<%lYa1P`%!jF*YIHBN0FbbcSo)CzY9;X z>fx7h;PX+)XU~J@K67^7YDU}w7h}B=!nWkc+O>MhkFr3%%vZ-N|%fJ{t;uN3D19n4{kZ@_RGi z1pS-7xb}Rd4!5=MCl9}wM^?twHpBm$;Kx1Uy>VPC(Lo>k1L$qtFsw|{qHNbvU-Z)g z|MWvym~YkZ$=_bXbuRx4&*lF*>Fsqr7Cm^2Jmh^8?>g~6*k4K1ReF;r%1oOkVWFde9ZDX33YE7=!4kDkovdk zHN@-4H8xMyTlId_ZII^(>Q&Zn6aLV)J0JCl&Ck2@h}Hx79RZyW>yyYcjPn?nR>G4q zvaSqtxA~FRvzAVAMuFzR_>#x>Ec}b>+R`)ITFA>e_f8$RQMU+#>rwbF4L`HZHuc~8 zON4EOOWp{#+ZXg#f&Pmn5Bz+BwG^hTl<^~txylHdcO7dm-14Hx*9>~r??+KSTCB3% zxgP&(b^E<8IxA#6Aj>ZuvM`;y)Um`Hex7l}k$pPy`muov_Ct;F`ClFHck1UIxDOpY zb}_5T^^aYlyju5IoHKYD$DsY&)n4!&$DJntExH8_>S3Sm}88Y92Z&31Ip)B zRxiQ(Dr`A7zs#K=T7J7VQ~g|j(K}|BVwHg71*YIzxE#>HSogS@F=qp;rx^aTDgq>-bkA{+AD}N+NsS7hf{8>JrZC;RE7n z(p^EKE7~dW7E`%g{5eU%t@EGdn`;@eu%&y)-0Y!MSe{`2SrmAGN#Rv_lP;N2m^XIZ z_;x1RJN;V=89JpOmo0Si7MK(*FXN>9$lR}5>_-M>%)Whod08Rm3PHgDZ6s2?C|ZuE z^OA0)A_}Moy`tiaZ9vL3$dR!mj?{U2nqb>5~+9vwAl!*|KS0=~)r=gy+AO%n{I^Tkhgb1t)`7fsUDTxRZ3*G}+s;hW?#RVVbf?w`}+jCUWT9j1HzWt6Yd!A}lMFe$FN%aEE9bAk9 zTIW|)qlKu%GA=o)Z(h~>%INI*)q2{W%*_-wdiEh_bIN2)J?Yb)DvE=9u+&Ubb<7gw zB**Fna~IrMuIE?Uz@o}Z0iuyRA(jE)5T5p(Njq&*diy+1^yFOAS(bxy9822wJ_X!9 zZ_|$LY-5&V37Vsd1$w?HYvmHVR<;GMm=`G(YI|ZX(oX6<86yE?T>*WUF%tb~t=XWP zHhpdOw_b&<{~cqx!gsF5g^%DYC%nkV95bl1;r6lNME$%;--VChO%D3u`gxy&Uhu;j zcZQn=Ie3X4B<~K;xP&YCaE+6XVDvBho08831oTy?={dGx;>9j_oyN(>uA^;6^#;9( z?{L9s)ZoQ%P5LGm{8bnHkPCjy1s7YhGu*Q-^fFfHq&Meun(_y{UB_#r3vTY8YMRqm zYkH<*s?E~+zr(=I^nJ$QZ>Hn#T<{*+AWi;exEU_^NCVeqb4#9S25!nT*TAuFefzaa zvHmuGde_` zr?ouU4nBexxbP`9a8sWZ25#zewZ7;&4`I`-T6PLN0lpi*i_UnBkToaeMo8%v8r$$%__JcFri3V=cPcv{+9&?VSNx#g6 zev^Tl^iLYN$^TUYH|fu4T+;D4;>RmaeZI8ldvF0;PqS>^ctt9x3^5Ukze3%z`?FoPyl`3uRCcHFQy;;ihoHz%HvRx#UZHYD9KzxKTwL~^v`O_G8J8XCxc=50mw)aPuRG?3PSxzP`6YMGo`2cc zf9@r1s^ua)FuyzVXV4@v+|Inox{a8WK_LxlM?e657yoh}2VC4HY1n))+)i3PcU88< z{|@b!T{r%|XxUEG0XeHUXZWlFoVsI>Y_oYywr}nKo&Hg_v&VK6?ZDqE+n0?VV{aw> zCC-45{w9S8T9O2@*7-c;2?TR|8Nr;vX@h!|yzg5W33xKGF0D8{qhGJM{aZrVXD*bh z;^s7C4olpjEg|lC$LBDfy>Lgc)B)qpnN7ZugYmJB z5Aq}(_qUFmZ5yX!-fBolsw0z;|ZChnP=-d1xV= z@3#xKk+sMJsa2R~_96E=#GaFw=Y#nq!6k!K?>Y6@KRF9$B8C$<2dRDE;f16>g}sL{ z|6w=xfFn=N$72|>7h9+KVHfjEy;rTdcP6jk*|w}8=2$(KiG8hK@Z_|mbUV|wuG`|a z_dGdU<5h7r z{2|P7!90-OnZ87Oz7yvS9OHg@%Y*AU#{p#z`vlu_eJFo1!jU-q8oJKH^G|W-+@7+w zw)G4*e73Fl6JYdPgL#PbFMf^!uYkOiA@u@P`zJg@ADynDLx(ORVDGo~x5p5ZwQqC$ zkeKujn)Q2Ptj~DKyCB^B@v`hA7(4VlmbSTX{<=POz4ISReK@6HeXk7{OnM}F{Li}Je{!7A{`_&)IQCgM<~U)qAzfGFghQ(%IEHeKx%| z8k|EfHE_oZo4$J|TdutA>Wq87>uP+G{dA5WHj@CCq~UnDiJ!4hosMwl;U{@Rzp`%A zT=1|9KGy}m!v$BfXN{d*X%Bx{V^p&%?-*ZFRl1kw;J{{@Ei{EE-O8QIrcKbd*?g*DWcxiU_1OBtlCr`BDovttH zU%tRGa$x*;G5yVQF6mF%onez+#>bNNOQr+I zttEW%Po7;xRmKdNgK;E1bfmO>g~ z^cA%3LFl5Vbv8KEW34mcxiDN`!nxcZV(!06;(q3_16%{ZGfN=&uE^%AkX>V;^fdIt zH=oyjP6_+gVXVWDb4&QlKJ90BJ=L(|(7gv%Kep#2*RnJZiG6k7z5jV~^`Uo8wp!?C^>G`uya zR|92C2_)C1#!_n4=wR#V{;KsfvgvI$xaU zg0g3WjpaYRH#E7&wrIk?#6qj$6fk9-Ns^B~=vKs)`%T}yZ2P0z&(8Yo6KfM#HL)*l z^~sTLI12=GpfQh|Si0`_HlZnHysf@^fA-OTYxU8OVh;7O7vgG<#K(HIoFD5&KgUuM z8n|ZXNVoGxkoQ}IrZjMl@UgyEHgJv5QJ)8W;XXUx8We~4#y60rE8d^o_49@j>_bhR z+G&RMN6^VfDXKMs@3VC51-;ihdV=(;V=JI5@QU1&w*+k#*2vg#+KO+G@GN`1%JNyN z)q4J>{rpi1=Kp__^OGfA?Q?rP@XtBk>4^Vo^y!=NJywrC`(Ez3zBaBgd>`iAOtaTopFP6jTFu`3VPM}(oiTT z23}QzlWR*oDvRr_IOmzXxgS5jN3Hm2-Yxhp#J5bR{7Jtj5f#gt=kb~!}BM1-Qebzd!@%R?)4Yvnjqqmzn zXf@)5bxPyAsjMK@d^90n465`j%tIXcT!-~8F?%6_! z)Zu*gbd<#(Uj1IeBp^CxUY|CIi36 z4}D`vHR`0)Ss5yucphjX1B2N$&|5C#nF)W#pu3FZ$xE9*Z!6|H9nvAc?iAX+*du&U zMOL=tz0dA?(aO`i5eJ@K;c3PDdbKdUSmLdlY-}6WfaT zqaF$U4E|#9&$#eAGW4%?PRhfYvln*+)S!dR_sk=nS3Bye z!GU0FKEA^W4$d|88?=j8K1R{dy9I4JjiGK)iN&D zd+>V~@2XH=l9u1Na?X^L<&?EkS|wj#Klu+Dun&A`QZUDxsD2Yceprt6MP*oDln(t{ z`59?C1bGx^@w~!!sL$5$eGs}Iit}t%pzbE!;}tWrv4_-eNE6Ob*OsMSwG@Nly;NG> z(tY^$=en{Zut#w17sj@8P_|Gf+I2-oJz(!QPn_>j_N=vv)HUK+=cEhZEP}rvjtt*} zdYsu*<#3fy=x*ciDc41u)wTo>L+lH1zHLj-DJlHdak4KrqUifNl81|GJ)L+yo z)>2yTaFTvb($7e1>wQoC+)F?A($9VLb07WOPe1q5&ja=IK>a*eKM&T=!}POPH7*~9 zbz-oUNS>DUoDukmAg|AaEHyYUCtcyJE99p>sDo-?XNfJH)ELA)i2AeXK4qQ9!8&a) zezX^f{%NCXLj8txSyYlcinTX@y&)RlJkk@O#yXNDzEQUor zvwTqhrO-dqz{x-O5$Y$(sq1ovSO00-xW~bldhaTJcKYe_$#nmLb@Mv#p-e36j05Xm zhRr&gVcX^U`5mA^J#71DxgIuOgzkCJeGHuqPPXIX#`}r(Gu%||ZuofzeuM|sW31;{3i2#*IR=dFmb8^DBkNEn z*lUkHYp8p>Ph_uQWB=+oZ_0^8*!!xzeb#L8_CE0r>S-yb9sL%&j_27ga@HEdZ2G({ zs|M{u0D8=2y@594Ai}ExFY?`s^CA8VGR06okskeltZLNr&v{c%z-`q}D67`HCZ-?q zg1l$j_y+xg{~+*=eA-rwMH00GC*wFC{lkwCNA{EK_Sv_SHe2=q zZF{Y4r|pM2vBZ~hV)3uBb`$ZXp6v5OxOUI3)0%L03D;rY3*BsmeKZ)q3N~&v$AjnQ z2MbUZaRvw0SKW(teGtyw2q)v7r51Wn?=l~=Ps2RT{QM~Go9L5yaIRG+-Qo->uABbU zvfsXJwWDdY4-W~pLbtn@_f#JQz?X7Ng>ETFSj$1(T5_b?ats=YHrHD3)!%B1(h)9o z?!h@IOdr^E8;?MD_1~D7BCJT&8QEZ80$zUR_{F*Q(a(T&$)ESi|6nQo@~p?Lw|;PpgyH8 zmos_HG<3$Xzob9X5dA!yN7Fffq{w@uDf$(C^T1!yY!TCpW#CEVt@qoCSK>JWIpqC3 zJP%4k`Z0febLk#cbYG}`_>L&^D)UGrF}S4uzWc1an}_Fc8h8af3tLeBB1SkjgAdb$ zvN6vx|NaI280OpXpY3$^o@v{455u$C<)2yQkLBtUeq(_b%U~bYov7|hAKdDDQiE?|;7ph4_fA^GHn2LI! z1@f^U7ePG$drB(nfx%d>J&tt*{2s+PObKYQo^mPoWGH!8EzC;9mIP)xd?Kq1wxgZC1)r9tZIl^uMA8AL>ceK*;L)5G7X^b?n+Yz?kzMZ?zwykF! z%J*UPyMBmgw#!?vr-byoDaTCgH?bU8sam&D>V?lgwffPSd*P3L0rtskH_m2+`yrIY zX2fYPc-#H*j(*f>>zmqco7(${x=&zz1NP-NDsZz?i4K{i_YJ3Fy zczDn+VZO(iu(dTS5^C#Ehp>JpCUIii!x*1C4BYAuK|c0N4(Vsg`WoCU7oXkrx(nZ?zytD8U2aK(ZZaqN=*RYh2bku{&63EIos#{$hWCG*Fa}Hi#C8VXvyJA>!Q5< zyH(zn4~HxWa|FU$J{oOcFN}3Vu97E#e}y{9Z^*`X8`jiYJUYs&_K$YD8SUxvH1uUq zZ&0QhoN38E^&q4JZ6o!NS?V(8kI2V7OYE=6l!f>s4>9fm?7cyrG1T#Uyd82_eK_6E z`0Oq%3;HgKI?aH8v;%EezfK;HJUFGbC0!K5f(&ykC33r9O z92{*8O|1=geEeq+}w*>j-5rh*Qro+MB7z`tK zh6ibXGuEBcy3=G%3DdBJ_B&t@t|(4{-^9&{j+xNZh+h1JXtQ%kB@|LW$UZMG4P}|KGJNtZM|d?zvxz(I3(d-09om%C5S?{jLo|T)X-Hx)=LOVD{GOkw zzvuJuJx}`=!#IL-uH(_h;XJ@hAKJUER^E%>xe|2`^>+(+$DtiV{hj)FMI`$e$~*bA z^hetQKFgKon?cwHYQUpx^;Ju8{$+7)fMQitZfIckpNp7n8pgZy= z+F#iC2F%%teCJ6H=CB>kgZq(W?0uBVIuQGRK-X_#&j!Ym@lq3&6|Xljk06Hp$USCq zeV!B4%j0Ozn|<*+**BHExY(g5^uPMnd|uef_v8t?#Dj<%+DF74cfr5%S9m1h-BHYW z$Va-iK)ygXZPPf8d;obaR2ROI+f9A&owuzxB3_<_>2yQ4(8a>NZ?zRGq)F^8?4vQs zZtIx;Bt2U+M)_uK)QOyRv5k$`i{vQulWxcy#6BUhDBCma*8*Cs z>{%0wDy#h}g-qlx@tX;LxjyfSqZiuwDU5KW94-HrYM@-?g}%s%CeW}fub8hu6AM9K zy{IcsMm)+i%e-w@kot?~y=weH#^F$RoEr-NQV(zs4c0HLtEJDv{WA)nPapD7$9dDK zJ2U27kxd@CxLfrz&eh!j|HwP7xvI~JmcQ6`!^nh`ocI9FuMOCF;98`SP1E6?GumUSC= zg$JST>t@$y=#yFXnZmmp@Q!uYkO|%#<{j!=^3SVy7lVF@v;0^%>H+GJ^@!&`kpJ+G z`Ux!HnfAE{a~F6m`eut>*Qda41ur`-)mqkL5(eX2XufllGp1D#?`KY!k+ThFqDF2A z=Q{!$G6rKT6#c5OpnX)F3l^j`>lhasa^hfBRV>y7j9 zj(LFbChzX#jWUyua^*oeqi$J7S@xH}&Nv#f>AI!YJD?q8^{X1&`&G6rLhU?*x-=E` zEcT<+=&7x(LlpA0%0Zi4%YJhN-wU}Fo`s14)SJq)Fdy|??s2tn-$2~gs)f(fp52DJF>6eZ-ZX+K9mqcIa`auz>~#y1awUx4DaVO#y_5zHTg_cDMMZG&Hk60$cguig0!b zbRB_yaw`JaEtkPQ3j1)|WvbO0OM`4%kzZKWcyGpgy2J84cna-5@(*O*#qz*D4By=W zJz#uiT=SnNwZgWs>(sBXhn24n+bY=8k&a$ZdpZVjZvDE!@C$#Q#r=A1g>IPd!uT%b z^InWAp$uespdkWWlE^OxYJ`v~mT zA3{EUcb)>xOcfX(fc#wU{Cd+ag>-j?p+XA9y<9*AEk0re5{X>)+%IQ)jCo_MCcs=eV1Y_-VG+lzC9VUI(; zx6A(2X7s0ydls&SJu!EcXW?L!x!h%*h0W+^vCP-t{T9?YVV#%Mk+$L}>Yv;*o`sP= z*}OQmLLRhnlE+Nm!DH_+`~8KQz8<{Y%3ko8KI0vES@O zV7xy@eM!Fx-|5OITQx@6V!p2FY5N}z|6hn6<2ej(z!#;*cn|55LC>WO#1$jDx@*5cp-ToP4YsmXyO>=!zZ z-SKW))?CQPGJ$dBan0!4hW%%L5<}i*p1u}z%+tXnlnuOd=IgDe?R@QV)CnK|8GTuV zAJKVxD#Gx3?6TK{e9iGl)jchAFepBw&io?j`B+lc3OPmvd(|_~xJ?*}imZKhH9v-~IxLy|1wh3uW|7ECmC}*EH+Ok^N zuV8w&+38*Xew#&;r)fSu+?Mq|Xe3-y*MFv8q{l*pVfQ!ead6tFXmjG2HQVxkMVcc| zWFmabGqCHYdZZ=mCt}cnT|Z&mS;i;rH0pg$8hwPY)R(+220iqn{?x|*|L?B{C_=LR zi^C+dp`|?LnRCan1r^|F*Iaqcb?h@J>I$bIS1E#w0!pK4)MU=-WYm%XmZ|l#f558-t@fusnezwf5Z03c+)kb z_?i&cuFRM`%{s5$Vua_(H|AY66^DP@@#6FJ>#n|XvYIyIx_tUW0KBOyCl_CP-8IE| zp=++O_+5R?HPeY-H@|#wCC+;<$HCUvE^YSwMUiT5>LzD`lZF?C`zr28pQ%?x9H;RJ4LPdy_#*z&Hld@fFg z7e0BVrR7ysntD`VD8{j^>zc0zZbsT%pEqr40TMefbWG08qsNTBENk5O3E4Tf-YWjD zLdY{0EDo5o6_F~OLLQlaJA#>k^DIlN13c@~3UtbXMcA^h<9K%*4_*ef^N3N4~lW)`!nSoq8^_r{Ibf|f1-ZZ7lL*Df1ldmo?%IiEkzILI2->a~Z(O%R+-9G3{(5n{Y*y8NSkooyJ1d;`wfkvX&fsH-o4Xa( z#ji`4^04orxTQ(I`)%IA*Ye)@&z>sJf1UM^Z$0!3u1lzke<;W68f6%U*XU+0D=PgLGW1r`r^jobUOZ>@HNdTlbYJd9-f5<-}#*Dh9&X#E!9e*n=@~P%Y)bphE zUgov-EQ7ijexBBTmccL$dBTtN*zC`L)SLfM;=|nv)+N<-&tIRgAwK_+xQ)IF`0lji z%3J9~?0g$XUbvcV{Y`%?X><4dN4y(7lO9TVIDXQ)#JXl)v6Pvpq^yzK?18uuU&%_jRy_o+kOBP~7dc2v2HSD_?8g`Basq zG-ee^XM8jvE{8R}wf{z5&w9^eshd;s*Y&EqVDkE&8_s*A$3}m_!{= zKJtGwX;b&>ld!d>f9@X-PXSe)f4cSGdo^zP{(Lf+27-M5O*TO%!BIZ*h0XLo9-c&Y zlMnxKror7}$^dLGlPq3e2LUj84H>lg9WYz3tav7tQr4Mzc|9v1>$&;7N$Yyl`PV0I z=r-k{q=&mdlHmQEnd9|Ck|NR0k4rm0UfuZ-yqT9|-y>c2ByU*dnngqEM9SiJF-!kX zt|heVR)*5~^5fB5OK7ztz|u7y#+{edUf|C7l75e7wVy9>v27u~T9s5Fbkh+^YZJ?1}i1K47&( zx()-*HEtIF3v7DXgXa>BTMZ;$S@jg|S8M#~WSc&0-&BRhlQkb{Q&(xcu)j?x=S$wN z@jXLqT;j{8uGWyQ2fb2S`E=@w6GS`)9+VfjceTdT=3}lJ?C{XlT2Y%msXbjgsL5X| z*#xa{bz&L#ac$A;6_@}wx!(8w&F8CxD z{5luB+y&>}j$O&Q#09^{1%KEDf5HXFJpL}jeaQvi?}ESSf}eE3IqAKt_@0OQt1Enf z3y#5oF6pyf@X0QCxeFe1!MVXfS8_h;g0m0P75&d$@cl0MTP`@}K6lCg0@V9mg`4hz zU+#i)&&sa&+~$JMcfs#)!S8m#x47UxbHVqy;D2zzPr2X;sG7TqZ(kRDmL5;=hzRC>IL&`7q)hWrD0yl+}Tyt?S$BXxvDC1d$|qR29*-SYNTJ3 zEtoGPw%w|{3nB@isyq@ESp=I^UMFI#{$`|{W+dhHRzLViai7Ti92 z{;1hi(a5N5d)t7V&IISiK}0d$(9B_}xNL#kVY%eq+f|XOxqPE{&MvjL(dO3Hi%Y8J zRxhZU?c7qp+OeQ)$$T6>fMm4&@ew-}=)Jr7R9USz+^(!FxuXhk*YEIXq-{H|jvc#8 zJDilQq;zh1Wd0&8AAGl~$_^QbWCL>t?$S>Cf#Xg4mfkZLA%I!Tf$a){Hj=j9Gi+JfgEj0+wp|j#Pd%o=YO_g;#F`6tP z?Gkppviw=bvJ!4T&NMDrP)SRsO>FBdg5>D1h?X0#puVV%xxLf4B{c$!;yec{cM33X z0Zx91R7VWY)C_F7CciT5M^RRe(uG`a`@B6`HKV-xx=I=cXV5Zc!B%`q+O2=3b_T1C zRxemEYnCL1?X^H#7CStb&YcZwXvv+hGHP}Zc-GuSRTWG+RZ=n=^*~NeNmUgJ_AKgt z-hw+cB?7W#>_WUrFl*wJkWOzTba_WfEmb3%>7oGRA-1u%j=!+I&LdJ8E$6-*o!^w2 z8`fKjuxO*@*rZJF25$kD3DJBH!)nJPik4<;gRs(;%`K0XSOu3=EUJ6!Ns)--dIKL}~X*X|ic;-bu7_)D`5;fl2fd@2BJ{Pr9!v<*J!wr0-#)ZH1z$a>4 z_zNC1_>3_4EHiK!v*GJ{1Lqi(T*nNY-==cCYv7j%i2EsxQ_fKaE;csC*FGmhzeK-} z7xiq?%bo;IJWJDy9;8j4sBzJQ;FTI@xTEc$tpBgN;Ab`75AlpJz|DBcUfB|^#A~j>-_%dN#+~UhT-zmx zkF!Ov{ugST@|fYup3=^6r@QdM`n>jdkx#b$s1|En_y``;IP(?vTas&!!N<)1Sa)Y# zPJPNA)K2`c3;nw;_*oachc+EJ`44cx&Aq8j`6s&2@6h-;<G!KaeUan(Ec z2rhe2OSpwLxjO8i7ra^Hj8~4Pq{f|kZZ>eU zy$EQN8tE_Bym^~$;8z&8G%n!^K3(JF!}$$zg&lmdwLE1GK7ucH(2v&i%N+EA$29H? z_kIT-=~u0F@DaSug-^YMkLdXc2Oq(AxbWHK;4@vvYmbAE;Lo`5+2`OR;}5So_z1q= zh0kFJpRksv*}+HfV=jE&ckrpud`>y|2!6(ePn_NiO!C`e%_mXglHUaHp>b!r7dZH2 zYd(bzK7yAy=#w>lg@a!3Qx5uora$YT7yQPac1e(U?a=hMXq@t!?Pgfx5?`UOH2AQq z`@SB}sCM8ozOvZhW702k;6lIJ;4?r9FYfmn^d`PZ0+nQZVW>t#PM+$jdWETsd#(!fXRfl3Ki_PQIbafz4USsEvQv%j>~ zz|Hn(gTX(`2)AD2Oh*$xX3#VLNImeb#zh{%2VfFEFUli*IzF$}xWr55fo#yY@DY5I z!N-i(sy^gq^Pg%vt^a#8F8rJI_b}ERTbJ+`{6&M0$^Vdn7a9EDH}J0;_*sohxIz8> z9H(d4O1Oe2YTTJ#83sPh;9sV3;V<)3DjfU;pKI_j^WkCxzslhMgn?ge;7uBra4U7Z z_Gw(=CHQ`Wj~Q;W!N;tZj%(amZ)E6-i25=0Jkh{S`NIZo_9tToZpKRvP9y(ojQG}H zXg^4NIj+iUhsGtof&rU%KyHDPm`AajDwHhXI=PY=y??6f31;@hYUPq;O}c(^uJHbe@f$` zf5EeK=Y#xBKC4{t4F+!3|4(XM!VQBTuctLG;R?RXh0i_*pF>*yR~>u=-|xcbn1j!8 z&F8p-kKpgR@KIl}<00{SU-OC6xWr5FM2%CQrhbA3AG6#QYTQ}wrn}%+zi3^~^xALm zH_PK8gO7=;fgOC>CzS*0Vc^9!iS<9tz|Hn6!@$k@^A-dDs=;TO3%*O^)U&CdCXGAw z^QsGe#^A$##U5?vl|cweFTs0|2$z$;3Rtk!-!RKX4~;wJOx3uPPe!`U$4Nh0<4*c) z7kt0LhaxZ5@j9e&iI?EV40=nT`^a2RQQ&=b7-*W>-bri)Wcfs6W5jahV^fyI1YF%(D!T87|=? zXN3kW)W#X^ejToSBM7}Fv*wD^Ex626l)NGMYCRrMp*;#N^C>GGxbzt_|Oer}Vz(%p|Njn4&>*xC&xbWHIz(xLM2QG4+a^T8m1Jkrz67JJl z|1k$H>4nAB)+O|kzWW@w=-oP-qrqI68Z@j~5Tq zxK0M!6aI%C;mQl0J>}7wmrkC4umADzOP)IWweywm_qQXqL*y5D3>;m>|3=+tRcL`3 z|9Jewztpc(6G_Z(TRf`KL-}8+*T~$s#J}i)eLcEI8#HvrXWBr(zP0}se{yGAFYb0C zIEHHfCPufDc8ac?#-C=vuKe%6)$*vqEHXY`l{-3#6H!{85>Q-kc&b*PX{X6ql(CJY>JN;h-ocaCl^*<7R$n4dgKd@5xWzkss+#={@IgHsQ{_ zJeLXK*WexpzvbY)MfpwyaDKt8xL_;nFuPuYAL8+#`5t&Az|Awru#bOhgyA7R@sN|W zJinm{=ekj5M89=Au;<|CLxh=t`v(jg_xEr|7`x>BCOMaZd*3O@(+q!+1bhEZIol_U zefYxIYfsLZVi^39-n##d{!g;bn{MZZ)0V`Gbo|EURc+raEU4WveGlL+W3Yw9@_Tmd z1*G@lA+N=Jhs&9#ZM5V6-`5Xw>u;TF53#3sJ4>=1eplyy+xqC{veyE?tk1o=Y7;nh zk>_>GC3@y~5OGNt(KT(a#8+z%F@2|wiA!JJ(m61i1c^`ALA2|6E*A!)Bbl+73t+8P zb{1qTz?5g~^@ek`X$LaMqU9Z{3vI%(axC#&u*4)P<O9hA(XQ8fB4}SCq_(M&_04;QrgU060)(Zgw#9 zJBNX_rz;t$(Ta zsQ<3)a9xE>-a#!;g^ma9`(4@i-E8zbbb`z!Gvjiq#qGObhnC-*cR)5y|Cf##KlaP? zA+pAgwT<g`7M#nGUj0}o{f|#Y+17Fod+uxB8~ey!>FZy#=tkA}wz@E>!8^eJ zw(4J$6c@yEcmKt{enpc#{r%s(MKx~odi-x!e>-K4r(04_oY64H)34|fU$>$;o_PNO zPe1?suxfnP8|OcAyK0O%j_GSvue);@LJ zcT!$f=OrbpTlc)Ix)sg#oLBU+I^W;T+s$8Dp&DP#x+i6XCm|^@cFd|0?DqCe+N1hr?)LU6+70Y2oYk^> z{6i^ezTQcLRKkhxslG{RzJ$!TyuCBie0}^MdwVCn;Y;(UA)S+vAKtigGvY8X>1EX? z^T*zSnJ=q&|90;{`tc6~%^1+6E!co~q$M5n#%I2SbCC{u`}$w^rO}W7V^5s_J&(u# z@-6ouE(u9Lfh_R|@3gnKzqc;|e){@v08J5S4qk1?cf0DH`5MC8t_J$wK>QI$e>`Xs zL38>JJ5IYH%Nt(CE6slhafBcLIM9p$&Gxx>r@Y~dXFM{`K&F==>*vsu6@L|n{O|Ga zzRlLbK;OX3JqYg&#Qn#rH)KYb;PWfWJnbInDFJb1+!LUmzW$#ey{MlJpt&D3)Xzca z<8{b#Pz^-9;{7i{UluKBo&wFe`swX|4f;9l?c=`#G;=_6`nL7ZPv4~7kR{&7cqRA~ ze0`yx-u~+#b3SD5&=1qAPv*0b^-XUd#A~4cTS$v4q{Z$#9zuHcPI?I=!7n3Cw=3!g z&%Sv7ZJ-H(hWbG|CLK~~ncstc`XXL?pr1EzUk{o(rhAE8oEAx^?La2 zTXfLZw+P|*Ke|2G_&vz_a zqH*5jB8K~(2fxV=AfKLJ6ptTy{R(CDSBt(2ee^8)+|#q@hw1|85x-l%gLFNw=ylX1 z`+dpKKYrKUk225$bw`h)_fY2Mc<`IN27diT_n=PsSJe}F3%^D8LGGlYa!*pxf2i}2 zPw>0ds$Ytxpl*0l^+5i@@4D5XODr1dNi2E=W$J}D?sNh zdK152qTbl#^Fp`X{h`|)1Z}UPeEfE(ME_mBUPzZjf7SKtQu0+w(M`S-`0oZCd;N7& z>QZuiss5G&ZN+jn9na%hR^}P8bgp-Vbp|QUH<9xQ?0v+4*nVz_bv^>V#|DR29k9||cTk&|o_+SbH3u&qE-Q`d5Hu#tP6 zV?R27ex>SlK6KB&MMtUSY({^~&|@*R1>Q+w?ESg$?^Bao_k;TyNMpfHfF%2e(1UY`|a z3C^+_fwNM)-C_swl@DjY*!$TxBYvv#D>IrAFO~c+50Yo|{1 zAHcmpyZ;UDD((Ie+;?jCPvE{wyMG4va_xT3o5Q$yAtU2=0pi!Z(ta1lSsu;b*6swj z*JyVV+z)7XPq^1GAJy)DaBtD>fp9;r-Gkx&zIG3T`v=;c3HQHg_b9l3 zq}^lT{)u*vhx=#ReL39EY4_Juj+q}nyX)81c^K5|E}b@ZTBYKQjov$7;~7afyNCM6 z88kTmq3_P;-&%@u1bXj0*eCelf8agO8(ocelE&0O^T4-(eUWhu`F1kD?I(hX^z~Eu zk)ikeobpJ*#`sB(#%=Nya`#Ve{K*|aeNhiKo;}>LGi(rEZp4q*@7O2J>-oOtv4NYv zlD}?1UH^jhX&d@}{h@vjUwG{!eWw53I|n;^cI+Dptl;;S&#wQmFZt!iT%2DTHt(*+ zQ0%XBXOGqHM{|Ekxh%cthpub@cK7qYZv*IsF!+t0ra$&9eFEe3cS$=fhIPwy!THV9 z6@9h~uI80x*%pAA3(A(Xn*o4gL#9$|Z=yv@s~0SqZSCV!xr8_F7^PofU#vx?6ez6a zc7EIMGw@FH2DEvE^d=rO@SbF>uVMo?y8J5ag3ooq7rWrAT=2Cn_$C+J+z-Q)^F z{Vw=n7yP&jF8gOtpJur7QSZci=#Nz=p5}sQxZtB*@QE(C%zt%;TkJv~cEM#|Rwp0X zx5J6c{v5>3eAR65H}j#JP3jh%A7vh^l-K{?ZAtHHJxF(0|zmu zElKuQ*&u}aF8UL=2#&67Nim(7#YRSPSVf3`(SKKAllO5ge@qKZI}(%B>7QiIv;(9n zbox)`gK;_I?`BJq_5a^6{L<<44_nfgniDo*{AfKS{l#rb+5I|%2wKh{>WcFeZAtH- z|AlkQEn5=pNVF$iJUidABV92fZ-i+x;`af+HDlun&f5FuheIi_DZN~FPs$X0zqO?O9A=P&q&(2A!nfFEx2ncf zD#bquHl9`R*8}#Ynf<>T+WVi6guJVsh_0HxD&<9d=g#za{iP}{X=Fq-mg0MD>x4bg zQhb}G!p>Bxy#6ckt(^Dds!&!r&SHPz*=Xs+l_@Kg&tHyj*1amOsAn?H7FE8aQM2*Q zq7sSF!sl>ba$InxZ$KT%(J&bR%VRXSMPb!M>0*dZB7e^u!e% z`KTt8HXzuTfViyqw`ZfTK`wri537GLl)VVHs~yipZ-0Jus4r{_y#m3;ZV9`i3H{fF zcF%e!WgNbX&xb81Vf0hc+m)y2TKId*vMuXRU7|*dwRO2RJod4KIn?s2i!Nye; zKa39l7hp3sr91;0U7Te*7?AWm?*Q163-{LbI*NFoH!|3G z$=$%d`asG9zVnfrJ+-j0C2jVd&+qf1{Es$-_9A}IkNkI=fkdb>35K(I=$ZT`I0t4 z=ipQHI_va>s`^akmrpVn^V39`NqIblL1@C7}zL= zczym0U@L8H^*px;%utV($T`C}{cGH5^-Uo=q-@JH@j5dv?2O<{es1-wfO?R-xi zZi20gx}hBTkagJpO`&0_KZ{O8zRMrIB4sAZ%`Dg{UPifk8T6C`_A!6_k}aX~Po9as z3|r?L3pS_R2011}Kig4$wu7E>q~rJEGmnHaCO#3R4KDo_=p1GGMV|+0?oER1MJ#{R z;|rhQoX}Z&qQ{_@O<&)XLb-=PAGTgRMU>;{(>16^y#B{GJ{w(0{f)Nuw*vZujVmc1 z^pu0Pzh@s?5xVUMJEFJ2ZY2799{Kd z%660`=sA6EO$z0ij67rN@1W%thnV5yMs_ZiNo+_Ix|E{h8;Y zZ&Yngc?0;Hu*Kygov4RR{M}&Z^XI|00DPE!s|p_r4Z;1z^}C{FkRkn}M?!n=YKWEw zk%|_a>Rco^gD%eAe@A`_gZ;**6Ytk6Ob1Nes_K7^Vfe8 zT~%r4>CZt!J-@9AuB9w*_ZW38%7Q<=xF)3rx?2I=-2#3L@9?1qkWYO6WhvXEXOUhn z2k%K4hH#nglM!xy+o}-r@ZjQ~N3A;RB0H|Iy%s$VK4r+ak0;*~VtsJ*v7cIb?V0+O zp#in^mOL*4AAovxJLK7Fr<;F!@!ctRgLe&N7z{p)>$ZvOLe%$=ZW}`@FaKH8hq`y> zA5mr?&-eHqc04J|n~+~NT?E}CPJ5w~uYnK48Mx&El-)T0ZKocOehqoKw9?io+Nq+U z2yg4F_l1xL{WTBmiPlih#deu3x60svqI(d|v1-OQ!GBNTs?e~zpN$TKyY=Lj&>NHN za{G<)9Z{4S*l92HKZEdBMR!N3+tWzPjBa(IvIn1wrf1k?_aLwwH8`^@drc_EH?XMe z2Tw+aKVDue(az5=Vzn80_OFlXEOalDEGG^FU-7QW9T&W zapb1$(fjd!aCBqn`AW1?Q`V=@Hk=6Th<8|~@9-w*C#`7ZOV34F#>T+^LDZEiXRZzn z3Ga#~;Y`b@V^P!a2(4KAePRLBh zm`XNetAkCu?xwnwT^Kv5@s0=HyJ!O1qPO{j-S^vQ$6M4m;HgF9F`iKc{#B#arF@9K zOvIZ7yjv05`w;kszWHEE6k|Yn-iv^z6lI~`F$R3c+*F%#E!xaD!Ir((GdlAw zUr)sC{Gu^p8~?_4QvL%r?X8|mGjH;phj%@TMk{S2pL~DHldx@n*E1?}4(`8#{rp$3 zlP7{#;w7t7?)N0ZM&83;^K@rB^c5pKBQBnOt{u7seaRuPIX@3u^W(5J=fl=K1h(eq zVQYRIw&r};niXt?xji_S$)4XNXJFEn%kfP6989${fc_=z(jTI4s#1dw4pC~&xUj1A zz|KpXuWje`yiyicIkfY_p1Njg53%)nUJ+Yw*lXK*@xI;G8_xIO%kUtVJ4w5X z;O?p2SHs;)yF+mI(eCTv?x)>1!97sBZ}a4|z^-ZAdQ*0e;CbbP?RPQQdc(uC8@AqX zrgp>D8y=RfnvsWb<$R1sywGkB#%D&IZPV?I?~9b3Z=R(s82W)N_z~E4?R5W{HDTKpc4z3fm}jMO z>>-S2d)y(#9s^KmCm#243?XeNX(^YCJJ23YnVyAgv^is}a!obH9kyWHVK~ll=KQl3 zj6LuiSBWFXVLrR-r5)gt%6BWYJ-ZI}>?gqo<0d;#B7P=4d5a%A-al$!Ibj*G^1L59 zgg?%qW7+Ad+_dz?ImZw98jf6~$7uQnc}{R<^HEj%uWfDXTX3hIFM*q7>_b1p{0}QV zKD*04W0q&j_Quv+QpS`Qc6qOT4l=_JVs0UyWBr1S0flqVab9&Z=IYe|tM;l^Vomnh zv$j5rvu9Jm7i9|b32lD7Qy!dCet`bywsd0n@$mdzO_PrKgrs{1y8G;|=d66;Q^AH( z%tZ_XXPiE}Yp;&avyQPY&rXIvGa=ZJk2#7#&@+6>L!KfF-Ii{UUq8F+d5ag)(e>JZ zH(lAB#RK05O`5-B9-=u`VePG|$0{astRkOd6$PEfD!%RQJXS&ZZp4pQmVLA4Fv=X5 zQ&2L-FRZi3I!Ij!YjiXzkm!N&7v;dtOibOg$c_H%*SyoAQYFn&0!ByNMUzf2Cy>yewzKhV_xPp2>f@Zg_H!HFM9n) z7@Ltjc4_bCn2kJ3`f~mo@zpeH;j+>g_u=>vkM$r5+`d`=yPBWL`Ih!7bj#7{pRe6g z)&bk}-CgE|c5N{1>g+Ezyj_*6pbLJL3tkMIV@r#*f!oS&z)D=`Stdw-T+>^557<%{ z`ft17955!I4LUmo@XTu)e#G}^+{%N%euy8>%#kag9eZ&nF3(Iq>zY@_Wl$N5l{I!X zZ%GLNd+w@s&ze0yGFRz`MU_~=T+Sh`uEwxl;UP*7_JzVfK z7d*oSAMJuqbirlsX{S78F7%Zy_%auKwF_S7g4es?PrBfHT<{lN@cl0MVHfPI*#=3GU{e$bAevPM3S` z9cJRGF8DN!b1y2rJ*LI2*q}FY*+ZH9OZVD9*+M= zJC&$k2rliBq>up%*@*9rVKIi;isy|4PkA#yo{jy#tqU-*w>9?j$4r zyo8UmFNF?V+KUPYF73saA8WOy=SLUVJ6O1FUh#i?5`O@3Wfb%j2)OJksPA!|2I@P; z-1KYLG1ncskR8$ka;!cWj^w8_&A@HUwZIXsgs0UlkFI+JeNq4H2azZ9ym=Ms@C!{4 zZjoQ$F>rJ_=BXpNRueM*>@|pgiNEX-B;`PptF=1(fB^a~@t6CRz{PEnKK%vt$GHMs z#b5ldb}$$DC9E6Z=qmon7upm}nvn5luTuO={JRR9Ub1y(p$Xn>8r8*Fv3!yR~AsoE#= zYC>hxgRO%h!w%5=dotEEC9B`8Qi-oLsKhn?^HlAYMD@WtajG~Y0^2m+Us4{-`2l1a zK0BE6M0#9i9Db`Y2Yk)4UMcq$O#AJskyCzqd|yTOiG6djkL@eVerMn8>{k%qU&g7N z7ZX(u&Xmb{A`oo&9&ClH!0!o#c`crV6GswM@ms#6om&E)58lB%_gol*ct?S%O;1$6 zc{M{Veh#!4zxZIsCvC+j5eNE7lc@gB#fc#hPyFI%Aa{mG{zX+M1*c7zZ zbw7bPZ&BS&pnw*qFH1JMoCo_l8tmV+eCYXKk?S5hd1TJ&1B3r< z>q)h2@1xtEdHLjulb@VaXY+mwnp$=0Tfg;yHhtOikEWlU0?f09VbJa^{F;4R{y>cD z*h=Em!g|C9I$9W^t`TNB#(E$d=BJ$b$xJ*`pL6&QSftR7k1Dk3KDO+|+8(U!=qM6v zJ+LQ-d)fBi<-K5Ex9s7z&6jJ>YiLi_<4v@Er(#ZziUk|%yn~|4zm?Qb=dJ0t{3hfJ zl{)8_kgv2~uyrNMPk3;!)eFBK=q#*q4`NOGm?pfR104-Q97f_^4;#4^U(i*rP>st! zPi#mBedG;$tVC?jf(1cG+qe^_4on;!&Rrg)^Iq-=0C_XOGk2M{A%F2#dgUhiM&vH@ zHKZ?#Ysj65Jc@N_xyzCoa&J_v8HW)M<}H_lP^zc*JLJ z>lO=D;rYnpo}Ap_YGHGtDz1S|KH~MP$sO(apaNy>3cPPZeXtyBLssMY2*v_h9`|4z zBW@?sur5xetl9R>s%-dcC;^XqlY*^SC$lEam+}h6QP+fhYE63bmW?%D)i6kPKd}vA zd>i9{gNJx(hpqI~wxC>rU(V1Ts@L#kaVamLtW4flo}G`nVL8(3$oD-tZ~nlO6GYvz zyoXxYf_(2mS+3}3=#7|Ri6_s`mjfAV=-7Wvn~uSfM?Lp?l>{M;9Oyp}B96DvVigESlr zSy*qe{z09xu;p}HaSU=WE()>)_l2_uL6*P=ZN;X3_As8{#dr??xNBZb2*dRA1NdRy z+mAcTmAQ9B74k0kj)>gH_RjMP#;MTWrJfiJojs3zH6jTZ!@{_lS&le%NIs>_-dc|F zMNk(rzeN%_rk1*s@#7fYV5?p0?AH$89#4y)ZsM34$1d$LHSf+a>ZK2TzMTQ3(B!DP zU62QL$cf`97xj?GIR8KBvPk>dgbhn!I-XSn3VtlzLSb%6Dso zb(#w1FuoldxE zm5wqcINOSLSy#l@zSf?fevUR9c{MTkiPVY3tmBdQJ=24Ysc>(FE>h56ko5i$7K_l9Thof{W1K!6yiS>aM+M2wiLVzYAL z<`rY?p_U%@&IN+ul8~SX)a(FlY4Lax1A>SW)SeRRd5_k_66-kzv@Jc@^IGr@)tv+t zMO*QjEzte_|FdS2VVSg^bAIQ0zu)hBmxjI8e?9ZeGtWHp%&b|np7{*#IZ>80M;7P3 z__M`A@_P0!(XIL(>GXT^vupd`hx0x1XVMSCp72imQ`nUDyI;V5>951S=)GV1Vx*lU zi!mn)An%i2aR~l!bG>)m$q?Ro*WSBr2mPv}ciPzK&Cow&Q}1Jye{g)lucgjBV$7k@ z&~ctfI(YzNz9+p&n^SzA&9&hDK6J+S$!>koj^$bn*c^0K5`^8cj+k$Y+}c+6WsWZF zzP`=5Zuv{3JqX*Rz0g*=FT;8bqz%GuyDzglP`~Z4`(nnAG26eBFV+IUrb%xpdlHa; zVr6a4!V~b3kcT#6q3kKZ&^OjJz`i^aY^v6@p)`kgR*ywM+rForhs+N>T;6NU(H3n$;b;bl_Yg6rS=8XQQ3-9xeGla*X1~p{zpL!^ zfRx8o!_@%|ijfqV@g zUV!^2 zt`KJ{#o~wj>+O!ZS!h4#Lj?4+34I^NDm9pMEjck1`Dq?T*Y)u&$Ril(-`FOHr8qs;dc_oE8Xa)xkkfZ;BC4X>mvNaMLT&hEyrYC)aL|@ zKUqH(@`O#W&+?-#zI)nbH{s4v zqOESdx9LmBu>n2;@)b{jY@c5x!VTza@`UeXA5T8x9MpyXP5Sc0lc^XJdZ5>2 z&~PkaLob1DZ?iInI+Y&N{pH z>ArCV{S=?^_`~v+2%lQR-2z|vF$O9WJX}E^<;5mtXEK1lHHRIXI-DjPa-@yMy zwnMI2g1yxEp+mOe-T2*#XSJ-qMA|qerQgA4Fpcy*upRk4L%!qTlUj=Hj(xD{lE?XL7$zA@%X(q?$Q4T zeIj=Q%EWbbT$7dpS%P>5rQbE>s)RhW3(8o4wowaT_BiU|k@XlSt@kvoM*G8ig+{i| zpQ7zYMdLXQJh>k3Ev#EaKff8io9**Z3)+1b^4^WH%RY=-Sf8(a5ot4Z)_^?V+u(bX z_HM*)55DQw{FvXrgQpcG+V>lL9)Ub4dj{*O0XDT8ZRBCxw~_u~gK z;Tk$SRXZxUgLVA_TvJa!96(Q7QKqMG-?49J{sH3&IaXtR1X!<@GyhPE`kVwF{xmzB zk7xDz7~jQuO=T_DRDKJ-lzoWmKgwV~vJZPw!t_S3e#72YfEpg@!HE zfBlu}I?K8C<^&IWpaa@n9q7o5_JL=kuphk5u?NsOkwMNuZaRNi&!}$!1 z7yr}q8OSezV=@oq;+UP!G+JhHp0nnV_0S34by&yh^l$sljd@7_2wpl5mI31v+zS>n503A)sya;p-vH{fVT2uCg}SYaQFerWf;zn- z4t@yF7tJI3eUN_EU^!SG#}=G1cr)sfF(P4e=Ztsxd`;OX3*{0y{dV^$?A*~!g1kq) z_+gJN(y!?;zZw_&g2iWOXQ+oxALbqZRz4XjpDf5VP(HxFRz7k4cCE+9W?SW0J}^Lg zWg8XHdw-ktwGP%^Z$Vjhp$|YkmQWvfZk9GF^?~_Eu8kKMbJd}(f9e(Od6gMCKG1Ov zxC}nH9BrL*!Av^^d8XhT-%w3w{uQHq7nl9S+ZwpgX}jh#qn;2z z7{ECH9Yf!K=>H>JpIzJ5H+~PDC)%8LgE2gKP%my>(9Wm}^zX$s{g;>iYhYc_9=Bl5 zpxcM}Hz|jTxe_Zf=tJ1%_QQU)URp3lLK*K}1=;-2&2zX%olp;u`w`_bKy0_gJ1=RC!*2z8fGv<)Cb#FCv)(=>d3K=w`bE z?fl*V^dN>Oj7qlbng-0Par}$4EL#)w5axaMJ*&`;n7{Kp;>el|zx+4bRk~_d=tl-@ zSHN4oM*G!$1^b9j)I;)huyg2{_JmjIjp%RX+#KtZb7ZxpF-`d>!|jlpa%!FUF%B3D z9X)vi%63nFZ$A1B)Jb1mXrDzI;!b%TpG977tVQ~je%~tn7v{^^_G#mv`MhZ!kH`{J zImS#liTq2T+bsdK!Iag>qhMbhb<^;!1!I9nlk7EYgF(>9``DU^_vtsycBp-t)PFSn zjq`j?-FycB`8nolJQH*u<&1kN%NLmA>BX2g;POAZ%`tDz@7E9g>uv5Oqz`~LfOb;X z?QOl|4PWaj*ol-=&GDRF>paJ6S*@X>&4+KD>oEqyJFXI4pKgEP_)Kq_DI;}(=Tzwz zEaej@>tKGN^iA|n@PB@^xfaOUfZsg4TZ)R$|1uwA^#(lOc%nsnIes4%qCF1%djMmD z2GAad{x;xz1MFfK>dS_Yebx(^VOJj2E>d7u&FKG9;)6SAZ$7jm`VWjpiz!z*^imq* zYpt6o!ev@7#@w6FvcvU!9z=U1eJA=S)Vb{2$QyZWq2B&lz3V#H`b&Xso%$Dh`3x@b zJTVt~=6rc4o;CBJ_byxu^r`e;%!BceY>dy@UqHWX-_mc;U%_6|f)nlVSd7D-A8LQ; z$C#GS0Zd2V7L0YCB}n@U#$Ti-9pBs1Up*P^%)16L=Cd(AU^@Cq3;vpUIsVbfk7*Hu zCbI$KPRg+U28^rGKADF1PzRX}7=LQ{h+&+P*?=*qi3wmBXBchSvB9p>k&Had^K_wI zHK3nb|1Ig`B=6C09 zA4Wb}{^Uy30qXk6FCrNn`?3$I4=uDy*Z^f_zr}vAE~@vJooJI*R9yCvG#lUf1P_l!9Vc^~j<&|K@jZ4e+E+WC z?Kn?;1a`2+JBIVRZS0en2G4v=7?&iFt{Le$KcxH3hrf($vyqPc+J`!AVvIm~&>q2@ zA$e^9PQR}Gj`rQ1uv;7X@EPJs{Jw-|POOnh!2g>|@SZneA7rD=qHG+OQeNorDPk<2 zoL5J??L_@h2XEmV^YVvLhwTRxMxHMLw}AaCu(NCbrS-k&;HVSo+rsxZ_?k`@Mm3$h zEUNW=ytjOB(y)u)zpSX$X|H1MiHl~oavek02GR8XW!}~k7x`L4*%mRFDWIYy)I&aQRtyRTWFu!X+6K!b=@F3{0{vx41O`H<&qk%uIJCaeks#o{Ly=Z4|VcvlAcN~y6m2*Roy(|jvn0;yCs%X6D@ZdcM=lI2zU1^9f$T?s5j(qrzU3k`Meq(0q zDnR zeRw_QwMOsSaillWPC1@V?C-x$*T%rMlcWw?M&O+re0Tn6$N?M0w~=Wc$Vr=R0Y)Fb zdtCp$FX6A=#k~;bvuUr?0d@2?>P746Gn5(ax$%rIcJFU+e+g`CJ^avm)Q>J(KHiI? z&Ju!Xzc%X2i+=9_#=Yc8KIF?frfvoNGT(`FOwacSH$xuk)$vE;_SPGE<=B#S=wTgV z9&pt-(f&IAI3H+3pY)$0*m@AK)X$$InOi`g0DoKuo~+N^ry}iJQO1`s*TywgTwnDG>Z1pLZ{v?T zeh0r@_~UyB_@yw`D>fd7Ub|r%I&WPE0iV;CvyXAkC&>QhN%Z}vYiG4)B47B5Q`Dsx zZ?9>1FCukq&I**5TTAL{E0!*@0<~7as$ErD9aveHf}Lp>FImKN%T_I|TSDxzWlL69 zl#8pZ<=AcG>WRF^L!Vq_En2d)qW|7iRw?!%DMwycOS+s=eBFs-(TbJJE|uQ|NmvBx zu!(J@+}KtEf$Hj|OUeRuOI9quY(-gJMICmzU0D%W=1>d4?LjW9UK&`k+(C4?i3f8RxvmgSe!tE|+#;))S#= z4jW??#K%iP`GB6CE56VkPoSi0jlZu}b5dr^MDNY>xW1@Y|@))A^g%MCyE$zqF`Ipc3kZpf-?)+i2hsRXfpp&*gZ$_wa^j6q+1{&%b<3f4Jx;AxP(nqO;c5FEw1415m z^B;4Mui1U{{kb6s1+y(2VbS^?jC#l?C})Y{5p;O;>#}HT6xpaa7uV}bqAsznLmpG3 z@RL6x=y@>yq4Nv24!>_$;g<87M-*%yvTbP5&gchXigv`_A6F1PCu+${M_`QkZ@iv= z>}Y<>9F*c^JP*k_9~xHBJao&D!mV-l#TIUh*^VeB-kqN7QI?~}bRdxYVRLu* z?vJ|Zjn|7^_=5YRcKE#44TY$~Xls}gmd8QLJ&0M zK2He?EbS^DvWXRv8HHTj=jkC5rqc;9<)zQ2Y)gbM6!Jp0Zvsk z+Z`Hdds3Ebw|cL88SPE-bL^g0e=g#*1lnV@;!{aJrhVPiCsV-)apa{xzUkO+%YTBN zzT!niAI~vwt{@Gdxd%==xszwaG8dJTVzj~)Fx-ni!I zu^V|k_vkT4w+n_)K$MmLT>sUv4B^2Js_}m^E|H@G=5p>a43}O#D8ji?m7om}*Vh|W zvS|u$RM(w~Wr4!yss8smb^qH6Z&5gXHxCYe$^UVM&ygtl3WfJ7oNbZEdi;?-RrQ$v;Qg!X|~sLQll8_D~*_kHC1CXQ0gf4Flk#~V1UR`_;RA+qlW{$qtdp5V~i&X4?ep!iZdK|fG@sa?Q5LUm4{ z$d??1_$P(WQP(5Y?>{Ttudb0;9#3gpU0dq@ZxkL>c%s5zQTTR+H!A!sg{LaJYEd|U z28v(hluH?dLF>?~N;GhXe&{(dWb|#HP?e|w^*d1ft@k0Ps*-c4KN|!;GYCEe!&xOgD`vj)Mh8w4*N1YbM|zHAV@ZV-IkAUNLBIdR1>Vawy7^CPwn zLf<+FPXEPtV76*6)r!xv3javq+JFAXAbgGvg1@Kuti}X1j~wSmoKg7W3g52q5%7bQ zXAWLS@Thct#5aHsR9|U|{&5%m)e29<%NZVWe2L%d6rQRY+%ec64}1$bApgaK;I|Kg ze_!#B!$NKzTK>BgUafFlUOa*gnC~w%AH4kFq5b^x3g4vgJ)J1ALJ%SIOLcOzeCaA45Vkg%XI1mFC%%xIX_~$!sjV`p2G7L-lA|z;l&E?)bvXK z0fon>ID{`L`rCmIB+m~9!5>t7PAEPH6`v;+{`f=(kYg#F{(cZXM-_d1szbk8@e#|G zEURz=-&JttuVUpwydzjxyJSs;&;aMU7Gkopybp0^y#~b2Nm-*fF_VRe9 zDX(OlJ9&>Yv0!({lI4h~M`AT&Tf1=8a!l>^=M0YLNJ3#H(3eI36=!a-i*f}@Qd<_N z2GcrB&ndGn?R)Vx*r9+Y-%AEP> zg>{%$UAT+{Mk*;vA8VFT@M@tftx7qK7t^v_LP@C+T~JLg25QSHD^?2>zHDirwpPwI z%W1}Gm#1HmnJp9dUuWrhsug8*b+w?$xm*PZEOS)u#3wA1TXNN|z`k2+#Gpc)X$<7)fI{gnqFRpsZqqoLis8LvW58o#aueW z$jH6E7gelSEQzF)mrIsoB3=eX zJSUbSrnSpaWvh*RNZFr_OpG$P5YG53c96P!RkhruOy#WJ2pEu@`R^BoHY1^h3s=|H z1?mKTs~0b1ZA!+0va$+PV}Amgk8!D5o+AMAH&xl6$gxC|4f9-BR%#R$`>XY}B?n#< zShCbqJIW@@E_LT99guukVTz<1q`_O(sZ1u7sG4s-AYDQKC6ufhk1FZy0Xbc+gmJRQ zJbMLdZ21bRyg#jKEK*JVX!Xhph+d(%Dn&qD6*a2@OO4d4U{0oR=r#D5^)*2~%DC$tYXap#Jj2NMd4)4ymRA*198|d0gT`Mp_+%P< zx2aQ;*?t6t3wtzERYyN3fFRK`l&8l)9+I_<+)N5<9F&P=R)Uese2g;*Zeh(4@u>r>C+Yc0)=aO zjlZC9<~u{t@<+!BB%i4U9#ZsfKl8yL_?bcQMD<+Ae4RJ@P9`}9ZpyPj;cj`#70z;* za;`J@TxH0=Md4qOU*T*oj6JE3PZiF5Z4Ki0jKRmmr>f^sce!R5c)r1Bfx_M8s#LgJ zPAp)Shns(=!N-*61%r=?e=rE21?oB2El;_^-SVt9=w~{j$$x_ey@@|>(3|!3fY!9JOYbPdARK`O5xPQH4cgVSI1R#+h?jlKg*y`SGb$L#h|~| zpx>i#w>}>?_?Y@UX3$GJQT=*I;aWd>-g|isU=^4JEwDbL*oe{&qz zsBp?-;@b^+j$3k+E*>@LO}tIvtd|=Mz0FYbOvFup{*jtzqWsj4et+?)3)l1Ty$aWQ z)AVOtxTcR&h0*-=`-pgjYd#t;G3Z$?Ta{tHL2u#<6wY!LD_Z_^8hD<8zh>Y!8F;UO z7aDlfh0X=}-)!LN23}&|a}4}O11~r5>kNFgffpJ0-3C6(z&j0mwt>H9;ATG?ujc0{ z|2%_!vVqSraNEFV82EJxXTNOfZGz->O0UZZYuh8hD$+DUaE&J)>}UyY4mUDW_lYikj%0kdHDM3B)O!Tt_llN36P9( z-Si57Ug2*2zvSYh+x2TMJ{q4q#Sx5r7AP6{GehB8&%Nqik;1i}HNMnEuUS>Q=rz91 zMX&8@ql;eSn-uOY?{*iTN|nJ*7axs3=AwUG>9fs6ukq(y^!pV5gD!fFA6Gc#{GKi> zeuuNs;?VkZuHbhSuJx($41?bEhqi(9G+oJG|8ISO~{ZJxs2es#eh_}vQE@;|Nw zZB)3HU*pdh^rrj=2jTzXAh@{5$;fS=Qx&e|IjH1GSGbl(Y~^99v8iqbDxV|F7k)xr2VM9dtA6K!s7-`6V~>>&%jMSoi1GS(ei3N>|r7tT3+IW;v|ZB zr$P8=J!wAr`TB&5zESb{$c4{S`Suz(%e7D8QV3jYdGxv|y-r-?Es9>RqtWvCRle!! zzQ(m2IWAo1XS;Bn-y9d7sIGN6G=EJ$-$ie!YrhNEa#y-=Enl?@*Yd4);aZNM3-48W z*yO^se2p$#%eUQyYdKn6xTfFZ!nJ&lyKpVvJ{PX#=yc&)4)s{sx8IQ}R^K}gy$_PM z+ag7vaczh5UHCke-%=N@%Ncaxx;$H4c(3BK&xPytfgibW{k$Bd>|e{N?R>Qhcl!rT zujj{fyVJOCz{8bX8n=~#GF-TR?&i8B9-3aS57gz>xSl6D?xNT00~37b^3m%9=euw{ zAI0@FJo@+#cdiqooL`OW^?|Eh_-Zw;-QvRaIw<|#Q1j9A5+N78ULO?~eQv&bz0*_| zuGc%&xp2MS=}{N1*EPN5!u7hQgqU;l)$5w>cHw$G(lahxuSbfCJ(o|Mn)jLN!u7f% zzYEvvj#^xJP(4I`|-^U>>w_POZwx}aVc zuGaCM<|g*PyCh6-EeKoo&+PQ`br@ zeRMPfn!MeII42*?bbfo)JU*Kr^U>)Oo!fHkL|ipjg<`##D_?zswC2GvI(hzA({rpx zp33du%sF)a2VFO`{F?4^oD5X{6Y8O~QwhfMvx(~Ty8Pb)#{A89+_)5tm+)U9em6+| zS`XKQhUe)dHjeL1b1p0c_n!{9kJ{yzXJj}uUw^Nq^o#q2u;r;O zMnEHzu+L8v_CKi?UKt;HB4U}~!-!Eucx65*j{BC2rULv;iW7*9C->MH#otMwZr8JjO(^4ah%Mlo8G6>vbz((0ar#nZOs(Lkz(kSzC1OOJUHf?J zdr?Mgrb5JK@-a4(ul4;&jLkFzv6%{6-@nX*I7~(O^R|Y@Ar=$jF?AyzQxD=X9Y;K- zw-Jx&9mHdL7x9>Sn$K(PK`f!S9~ja4Zarfyi7jW>z9{1?#UEIII8v5==y&o;iS-3^iOpLN~EyR>&45*2bNMH=Rcy z&Ie-6`A3M7A47&b#-_PyAeCbgLvd? zhhZN8;6cRY#9HUegNVg*`ey8T5+g>EC--z9ePD_xu@Iw-`kNSsy?dZD#2i74=0y+b zv@MKzr_zpxuE|$G$CM!|(Owfo>}!*LH)2>ZmJ;j#>{=V~ln}Sk*ztxu01IPa~vmoH+5VqcybfpT_# znVp?4Vu$7h<7$G4Jzo0dW!c@|o|E-d8PY>8L-r2J&Un^Nd^2y;J2Hkg;xA&au25NG z)5iF%J2swJdnBoD~a~(SpQNdz-2l)qW3yk+9<9nmdLa=Yf zY;QnZ#fPJUhY|nraQ8nBZDoFu$gtKoF0IVkF?Y2r!w}?u<`HkxCfMr^5uddQ_SwQ% zgFo};t`Turew>RjB4-V!vyi8Ao|xrV=gA(C`!3>pt@ZZ)vVL6jsg_in9|`VYT&0jN zZZG;&#P=D$w*Ya2PV9{hYPZho(M4lp|$=MkIV72?pv*Y!Sy zK~B>fA~mZEJl3BVEIvV>FJ$fTMJ^ShG)NJYs{CeM5 zVrAnIuEU8TwCJJn8|_}UGwJitUVTWj;km5MwE5Q%gGishh4Ti9d(#+eDHbs}*ZjF& z>O2;FP5Vf}eg(|W_MJZp`}1_rCZ4`|Q`W8Di_fBre)NyJo(1A4vEHRUDEoK={CN%h z6yhYwHqW}!X&BGV3mX5)wMUo_;}sr*tv>T!mE?6||1rh_eN5C~eQHVG9#K=u-yqr!fA5A( z$I3k<{*ZjebL!x?5K05>t-CO>DQ~-{2DY`i^G5jfQJ{UsQ`32?C>eq_m-m9F#=1e2 z{BAVPUjlC9H{_}5iWen4NE?7`fl6ziup5dI_c86}DA6%%r)X_P-}4*zg13-YQqc4&O$BrKF1=x*T>hu}$1mfI43Ye^H4&KfLhm-RK9T&Y-In_!7*! zNIh8-L`fxL#!6kK;1{~G@tcCUcHHZWcB^&$JM4v)*W#(c-XA3wgGb);&=1b@PIzh% zzpEtgap(p#?)-M+UcL9Oj|1Ms=~sy6B=ot(tnYW#J{jF8%R8v|TJPxT%=2CBo6!Ti zz}|K>7VI%^hNmXw<4DPW5NpH!D~ZT^A7cIC*Y8c9&UzmWzD)ZvX+UqGZySPslrq^D z;2hVK7wc}MyeWvESL+=w^E-$%e(!|oESu)@9QnY$T9Losd%<+dqVI7}kGw~rhjhw; z-`V)x3H!ir7wRkzHt~JZ_&qfO{&o}Pm;gCu;P*ODjUP6Vm*A;kf66-ci1oz{qGe^R z*OS(zY-$qr_1inblDS)5go-sZ#{!q~8JJch5heD`h(4M+@ipaS1 z5>XQL#X1<;a~bL+1mEtBabj3|KTXc@U=NfOq|ZZ|?gRFhOThCq%FzXz2yI5JO4vKv z^dCfg!w&Lpu!6<;KF`puX3=5C3anO*OA`|@W^T4SLa8Dn>05D*4@5tt{aL63bq{|> zex1sX3&_xSe_y0z9q!Y2KAq~%62toMwWMP2i=jvh{>dV$28*yu)}im?7!Ui+oIE`? zx~Ua@Z>>l5xxVoy#bqqFolAc3v3QdA4P9Pj-OZSV=)>qK0{U!hNP^soKFmF?#WNAcwg3AJ><7;c?33mA z7XE{Fc`0m?HbZ-4{nUEnr_+vN#gAZ@vFMwBByEzmR0n(DSc>CMPhFa*?@7K zg?24k8g|56feU|*vWdjNg#!H^ulGWS$=Jv8HsC`LpyA@1c7b0U;%yF*F*Z34lw-i= z*w%MutMOm+Y@B1HVzVwG&1Oj7zkA?8NwZ$EV}6 z+&Zs=oqu>NQo=Eqv>lG+Q6J!eI)k71qodCj!;f_RF;emj@~icZn@+!|eK7s+S;#|M zACG#^#QA>M1IL()aju_PK1AR9h2ER>|5iyoK zkk8?4q~(59^kuYp8~!u}<>&$p_l;{u*)9UzJ*tfGrKcv~KJDyT!_I?X3v6kvY7^6-L;CM} zKF|ELf4s{3rmVNfy7|U*)=LWVWxZ@eTK2ad?7hqWmiM~Uy++)->K*JIp?rt^W+d}c z=#;v&=u19D`$c~Ty>DTkgniTwy#X0--90XgX{b*;M@xN18#3B0gUdJ-GE&EE^Dm$t zu2uB_>=gG83t{}K>w^1=>GClS{Wp+S=d0^cr>DOVc#e~4VGr(l9D%f^pZNskpiX7F zH~ZyvrxQp=oi!+(6{4J4hqd1G`SU1AnfO{g1^^0ew zJKK=gmj_~H|4m!eWluQ}DS7j>GnZjL+gNKI|MpKv$1#k6ozccBQHQ+NwnwZC7;S7M z%FSQ)fBJbV7U}i*)3|T@5~Mx9hjecUf41huaS`Wo<{A8naSTO2ehqNi_i@C!=YFJ^ zBa-_o{cwVf80Q{2zxKlk`8daXTmYN}l#_jsDXKM6=E;2*@$p%HjL%BC z%JOqV*mJqTBR>t>65`%u-~oR8L)&Ki#NKV#uk7qvXD><8Ge4B!@IbhU$=LQWuK80L z+y1{kf7-SAyw)!0x~F+W>)Q{U-}>&4obu~f^p4&TQy=m4-$z`1>h1*d+~8{pJ>uBH ziGPV|#e0Uv_b(cD@dw#Otsi82Fo!!6f2_B^9ZR3}&iY2b)1>3-H$ksm$u{>3f&KhJ z+7HXmeBOf&D96b{U(@@L<^4;1t$5ebc#?C-*NP67iO&@I;3qtoBZcfIZWJ9KWEV== zzW&_u2sO9t=w&Hn(y};u!F;x{*MOAA=aL6=+W*;nyU(Zmj!syH>)qy6-VrmN1;>+@2t+-rq%{CF?Z*Y2r5wm;ghA9kAp`(+*J_IRT|e;HjEJ?E+D=(+9D-aCiJ%!!%%$2X52GXtMF z@yrro3_N811tVnaPKHvXe2CCCg7+rl&sKCx38?sNH!C_FGmd(yRCJxBLwRJ(%fjXn zeqCr8#Z?9DgBGZRohpsgSN;emZrpdB%z6JAb$^q?)4A{Ozkf{KzuUYY=)ZqP-CyV2 zcXW)%ek>gMPrv}5hpZ=6wi}(>^8O5U-zJfYCx|$DQa4P$K;4%%r0!p{(pLm%f58UH%;Lk5WnHpHOpKOHC*Sp#mz_mlLU-7^TzdXO=xl%8e#1@?1=hZ1mt zL*q8+2IBuK&TaWn$@$!?0_Qh8!T(8O5G`;#ZRr(U#yJZmm3kJbU6`%M-hw(ba zzgppq3ZJ9!dWFBHa9iR3pzy>C93V&GVwn@)#0jrdTeo6mMd_+Viz-%%a_7dvq7_S* z23Fqege5|hn-yh@w8I!g{WOfL9;jO+CYOt)EABvirt&3=5!+rMY)k*e@>NThPRq{9 z%wmikbi+8$PIn@pEUA?VoQu9#K4lECv#fTxiooJr-rjc&E_ExG>VQ2m;tG@AZU$^2 zUN_PF>X2m9JP;Cl*z&sw-2e z7M(+P`?<-q$PUZfH7%=XwW=qsl~<-Dkw*u?b^l9xWdaU8u6Yor57viX8_I7C93Su8 zIidQXF)n<9a%H3+2~zFBCM%ruCZ3^i=BrFkX0YABx!z45XOxR0J^Mm^EahS&9BzEF zYTQ~L-PTjpiIzv>8S2C>PdbIhq4_vh_)b#cnvcdG=ZqB&@-e^JJE8m}`6v}ix_IT^ z$j8LzD_qm}N@{$Q=Azg5V+v=!n4{@CP8fJfA1cI0gYXy1k7;={|EUTm|A_`4Zqmww za!zti<-a)wu2d!Q83un7w-wHBjZ8lC749xqwSjZos1F^>fb^CI@jF2^60Of1bJ;wgqhk}e<$u(mr~PR8 zLk52{-%kzPl+%nIVA7v4_?z^WYP4?oGZgNYU$ZulrrN?$`edYo=E)BAb}@e`dL~1+7q3sylFWgnw;yHqY!dfW;|X z|FG|f!k?`H_1ienIeDBnajcp9I==}M7Vjfz4jpgEm>8EQz{eGm|rwiBVbvfqXKF@Xg)a21>kYH&*{pxi3 z_a@-_+$5c14l;}zZrVjEy}SIWD*bBL4K2TB8NkUv^>1I~Py|(mtp6eS)9H2n^R_Ds znXpAUGIOmoo3J}QdAjSK3_h~>Z~t6`bM;kSv2PqGeP^nZqFN_Zzi$0ut@HG3tN-|$ zYn{`x{?lunU(^r9kinL6*y4PwcILit&|RYk`>S%U73*Nb&e~tRTg6adozk1%fpo?BSYzg_c{cW)dqK{DH)8!x*pKzZoFlLI zewC*)=lZMG9=R;GCy?^d{H{JZKM%U9NVr_T*{$6}sb<$-qzr{+Q~Kh|3oQKwkD+8tYfy3sBzsQ6F8{U-02bWE=C6I>fbpmoX+zWF8n=)Is^REU!rhKeV{`@&l({Pl7vIn^jCe}S*EoZpvx%}L& z+pL_>bNh2GZ*LawVSVYTxD-)x9D7zyLixEbYnN|)n%3KKyo01{{r7zG-sH29_RJ9? z^9SIuXoMa9K??VJls-o7@c&DS^?{Hmg5bvo_%9~jB zO?cN|2RUy44?7%$ezro_$ym#J$Gx+{p@~@Ahj-e^2}r}=M6931IgXerlT)xr{mkH0I=TNp3 z5w$t6(s}2@v`h!x^re%0qeNyW(zjrbSwCdoEjkZ-qP*e#uxawt^-ek1#^LmGv0fZJ z{=6y-#)o>*ZG? z-#D}rDR(^H0gf)}fNhNwqoX>w-sGhO@k9`7?B0IF(*!*oZb%ZN9>JQtF(Q}P z?xFa$1M;SvnR8_K21WiF~#)DUi?xX^8XC?*%#pTOe6IZP<9pJv%_GLSW6Q};+GwiWEs;HwIZNW2R&JoyQ71z&pp z_L83{M*S1o%R=EjRd{Chk&Dn?y7A6FCH+T9^=L0Ws=e%2?WNw;UNX^MsLvqU41K+==Pdi?6P^5WUZwtTb?=_6FT;I(cqFJtXM-GAWwF#0Q_?hhF0g34}o zVT@#nRv3&Z{d_y-L8)A^InPeG^c_!e(}`kBDN z@9@8%epg|A8EI{U_OsZ2+AD!4t2GyTtj2nW9P~X+`ui)6JGR|3Hyo)F9rxWkH_UN| zCk}f{H`@EUYO&sTbnL#!&9S}PuqV5=AMCZT_o?%E?d*$;g}i&AgUzFD(UgNd!@q;J zfwiwqtFUIRHcdQX!;eExhr3ay0r=cP*bu&rJ5{QDuJ*TbEa~#OU!r}`?+VzA2R`>^ ztSbzyuz%6+9laTQdYp^{Z`KpP9fQy58y9iiRd6W#VY!dDZ2w$C?1MhL(e`S6qc_vW zXm6~WdidTAsH=@bgT;G>1dA`i?<`#Z06OhDf;J1ETnS%15o?7O!xwYxR}PWO=!Kba=b7X=Tuqn@_IrpU+CV-m_Q^MlNtpGDfaPdM}L2JPq2E$bi8ZL%+;4UEpg zIz!;xJD%V5)q{@Zdj-EUFB4cN3VERu=JP0g0cBp~i`ra&XiCmT_?!xyKZkbR1K(U$ zHMzG3Yx*9E!}oH~Vc}vi(vLI~MB?V{*lWEbTC~@G9?4{xSjQN*zy~Mn#k$UI)ctb+oZUS8hba`0&y(Efs7Ys;u7wA|f*3TEvFZK8`Y>wZd@tnHN#CK4m@plQZqDf-p zBDB5O$ebhe+dJ`H6@6gEq4FF*aLV&j{{_=44o%Kkd}vb6YtS$CnfrO9?HJPEiuC2a z37e-NeNd(yi*F9a=CVU;FkZP}Z<$D%UUulpoQkR$IrpoycorE)nJD85oKt7~jsSc` zi2vZ=>lWwi{~P~)*NN8<4{7)(ZdhSme^W_`RkxygNtv~Xdpb|EX02GcctssB>z3l{ zEN2r2>>~}ID3;aK)h#Svf$c-Cw78=~h4tMj<=?|Dzo0LgdvoE9H{39@ummw|S65eH zd*^a%O8WHG{Ig0|)mh}K0p>15am6z1^$d0v-is}+tHgH7YsxLT`-r@MePH#HWviCS z-KQ;Xq+nI7E~}_0uPB$d#Y`MlK91S>bNODowqoV&6)UasCAHWpVYw7R65cFjU5@-K zu@eS%rLgX-(C=4CP`Gpnw%4}i7AZNbWlL)Dx)IxrlwXM=E?tE(^0=jzvX(j2OUkW_ zrqs$=pj(hJx3sX9)Ix77EWFNKj18vyQqIG6C3mb?iS4)tzCUy2$`vcEDdiS+#^AQo zPOVU#7PoPzs8zzUvcArq%Cd4Hueo-J(>;kS1de(9N9{#A6MKy6r7qmza0G5KeGzGJ zXkHf1=M%t@!GBbG?BUzDN9hc}>v#``oG;IJ*5?#*TiuykWA4Kql~Fe$w^!93k;Ax+ zZQq5Q>y+t`UN#(a-ICsyxMz`bQ>Ivdb> z<({zSk|OUc4-mc_!xoeLdrSxV#*ASm` z?CAB}7q{xzQIyHJJ;46C+&j03#3e_MUCZCUKYFZ?zu0+Kso*O=6!Cv@&5koysT5)4 zJ`CqvQ=<=QZ@A!GI&poiZHu-^+>c)#(!TIJ9e>2P6U3oyV+PKN&)0Pz?+S6P!VfB3 z$B+58!siTi2xXnAGy|>iapuIoy2gh|23iZ_&^yjmvF-cu$ywpPOL^kZ|M&Oh3xJ!} zp_#+-LGU{V!8Z@jF&7sZ-lIVIQgf#V1&gv-q4vE?`oQ zO{>Zkv9VXulI4r^ZdLvJ9#t=1S$lIuUD1j=mM>iqC@;h?f=hQCS!7?i(8yYEOa&3j zs_%5DTpVuZzH4f$E6L^D{i~cleC0xF$x$m^Fb~!ro+0`UU1xk}ZsOI7g7g??_8p3y zAiasds3^D=Ko0QKbv&+l5Z8Sxul2iM;ujE5N1Z{hUO&k@EedBmZTd)k>`^%7JYR$O zeN5qeH*VsOE1daGFz6H13n+JaErq+wtK-7yeA5-L97V75)wr#2=4-B1S!&>>9v(CB z3k^9R^EnsfW8yCuxXI@u15Y;iAhv`&$j379sS4NSI-%~RD_oaL;~54YQ=dTtH|5lO zy}RY_HRw(G_oyz0@}wAYwke$TV&caPdec5b3TM6(4L*tLrMDZOp>TJ-&lv>QYpJx} z=BPY&DtfIqjkg&2n)dLKftz};RM+X|KUv{!{;3LQxlH~uTzvF+waCRsZrUN9f#pFyrk>{; zxaoghQ@Gm>k1O15hf#bfjl*qMi3%qlQ*Y^m(9anJ*L#+KMbC=fjc+vaRm=FKe0M9H zdN%PbgYbFY;6uOKDY*#og2BhcUsSlezK$7uOg$V|xLf`Y2En7$cvahv?uUjeT-%Sv z;}!0fC*8%TMU^YZ#Yf{a3_fPNm~Zeg^|`>{W8&KlKBm3x83doo2L~K(JIqnI+YaX` zoaLSDB$fXzHE`1(K4aih4EloxZpwK~;adN3$cM*qg=_t5`~!oJske^|KBhhND%@=k z0xzU_xbgTwaC84S+UF)Er@4QeiDxK2)SD@1iNbYx@rWf4zruBSHC|`Xr#PhY-=Mw=CGcG<_|5$1x4=sT; zD4cSd?Q8oW_@jgH(PL&0_)tH3{AxMk^u_&FmwoGANzWmqexBFkP>uUlf_ds!;|G=A z^nHzMI^7oZ+DVn%`OXR#8rSp-6oJMy-=GWMuC6;>xSqfG$c1Y;b$x37y1f5|HJBAk z18M>0|EYzTD5HfxR)HD@;>P%R$#-e%EcD zQ}EcM42y1-^9}Cw9Ok)g50HpglL|Mx5P5lDc^3;i2i&h)<#2wgS1-%b+`WC+8!L^M)yjMCI8nugKKgQlUEev;CjmEy;%D(&+e#4EXh=?y{yN& zy90QaT90*ke!MH)gY`-ET&IM4Ojno>Sw1$(YKxcN73;m)@S&{=%EvOyiN77;&MOMKdnc7 zc3t6Z3Ly?w&tm6&J>QS_EQa0slBd@r7F$yMj-(x4kqcqkxPGnlQM+Ry@ZX~j{hLtt zK2g;&##tw_INpo(M$Jj1 zGZs9opE)t;5X8773A*|;M%;81anGz_<2R2+d9j!`BlG}iMpt!WO)6~QFw4Aq4a+>b z$^wSD!^iZ7rGtn_n%;2+Y z56QLd%v;wlc~IwE=Z&_PaVzSSb_PD97^@I{R-AD2^1TKc3-#Q`6W6q7&!m`KKg#*HbSldV`maOBK8p3=^iz4S_>ry|`LW*l z?E-z4cipV8mF|4Efc7ib`&&D&&%FY)w#UkrYix{f6cCpU>qfDD$-rc6Ibf8{ea~FW z&$ac^N5U_X)?Dj`n7MmPu?9#)*{!_iiRX6?BD~A%Ir$j+j!RHq9`s{xc|BE!aE*0k zVXXtbmS02_ASO%#;>U^EMhq6HFve>D;}$Ql#^>7 z>96^X#A@`3n9fY#cMe|E?teI$&b&#EFqWx{1D=rb*9T)x`UD)QHvstZO6>9eW!-AJX&O+bMtBnokog9HS{Z$&L zULWf#7xj(rct%m@tML7TQxRT#x5l!33Bd2eUuIu96ZifGYe(NfnNikamNgD#MR`W*^2Uu4*#Yzi2Qj`# z_4H;p-1Yq<=vPMm#OK+(sVZgPw}*&3e-kguU&A$!iLrJ#2j$;}yt}bh?lW(~uy2BQ z5b0)uM+4SxF@1q0nto7a?aPZ3ch2lwxcXUPf7}_rE6Kt&zHpvC6aI(iKR`TgE6xUX z;dEZ_@{Xz6jd;D^flLADBo8_XpI=*2- zpKoBFWMk|(7Gt9>#7IQ@s-cZdjoJ~bKpl2`9_h0; z`*W=2#+c)Q8&ft1&bRN}|5Z`*S4wCsnEYSpTbFH~D{xNV}^1Fp|Z!dbH0w{uIf?I^yCxKaR-yjC1Ncg!-avdvNW?y`SN?1$IJAK&E7j z--C#YjB&tCcjDe>zJ#|(1mz!9$)V-*_KP6 zLabo;Z0`HfiRXb*Z(I|{(=ihYCU%( z)Qdkxw6Py!+n|5-qiwA2_BPSS-tn-nY0Y}k6pV@6cc+)*+yrT-7(+Jt@V61;nKJz8 zu?^P0!p=_Urn(?qTP9j3DBY`qy|mpu59?Q8Brs z^5E!!P!ndzA(2*2lF-+wJ| zZKlz@bf3kvQU;`vzsL_V->d07gXBpaWMPf4)|Xz>ZtB1+zvIhBb5EGVx)1nka)3<(22*}ViEjh(Jp2-AsgLdv@;N!s?L52Jk8s8$ zXV*I4ck1+9Pwoq;XMXUZy?g@SXN5*IrG)as%}6Kp^Y8g#?+iP90Q@=5VEI`evei>-@O@IrBZ;$e1#G_%KL7064mloh#$8c+pTfQ= zd>(b4Lp^)LhzA(Pcqa?bCSR0!nxMl`8PFrwC(CaKP!I5Phoe)UOG19x73dqIQ-7T_ z#VfMjUQ@R3ZP>uGXU?y=4&$>&*TszfS%Mg~5zo^Fs~6IJ@?@(gs;x=JkWWL}Xqc zAg#`85#;$X@@qhTF{!^vid(y+H_qeP8@Kl2-rt;#&F)6KrjE#iW#cml>%~TY6b-%o z6ngt9^tK;9F&cXNHDYA;U_29pH2;j)r8+J3NglTP^}Et{sq}9ny$?EJU;nl*CT-_m z;XyeB_PufYTIR|AHU+Y!K(+?>#{k-pg}m7Z2sxJl`+bDpIC#>0VpH)%)){;=?I`5I zo*DSn{@p^|Bu_=Gb)*mZf=Q-N)a4`p51|`@ynFHM!FR3!Y3EM4`MltP&!S&s8`Ix8 zi|vINvx_E6;Q8X-7>wW8HniV$+JPV6B%D!t?<*^85MzN3l%>swdN=_8Sqk4t-;8lq zi5GP-5#tH&@iZog@0elhpQ6pkF)7O^MEhr>?J(QCZtMCvpbX!J!OsEbHwV7GwUAfp zh2vSItu1x*#PmVf+eeV??Am8r@!g>OW?C$;!#`pCRE#CguHC=K#&c{aT-RDOku4^=6ZN{|XTQpgB?B})r$;VjH zhq{Y`t@U7B_%^;JIqvf`^&kf5J2-!PytnnI-5ZPZM0C~h@%U!AKK5dKGg`6<>GCYh zCF1Jc3VY56j}MD#LhUJGDLVEais%K ztdZv)5q^UA6nz)yy*VQM7%-;ywuo>m&KF`VOB&tIF}65tcVaIe(9_mP%drN1$%CMu zWQmbIxL1!hGaUPIbYpB-(3!IN*SLrMwJv}ElYVTci+(BQn zAwfqO_$?0k4|V0qv1$+6m<5_r_?H6s(gOHW4}51S>{Gx#ALjFlH7ghPx!2+|%zVrr z!LQR7_&dFFj{ZgX0s1rg0k$9haSTJOL15nlTr&^;5`#~ZnD;R|ydJ*L1OEBw6Q-gc z;C<3L;{s>?fj(p`e8_$HCd-M{;DMiW<{g|l32z$p-4lN3Fvg#I%Wiw-KHkA0rbH0Do zI{V3gMqgF-V&P4g8^!o@$W6pP@m+v9)C=HW684@7N4C|*jNZKc;TcW%z6^deac}LP z)*WfU_k6VzuWo9_Z}#J{;mo$!aBlVa(jGdYxBKs#9ey2tc^KwNEZD`D7^BL0Pw2tI zJV)t0m=oF9KQHnjp0V!t=D;T=V%}slzmtQ%cIHd1T07jl{;DR_OS^T_?%00dswU)- zc>vEE*?)(a!${+gv0Jy?8ylv6w6EfGBli43{DywNS31JRGYEW}^8fJbr#^%ZOkZfu zwR9p6=ErY_58zpc{OvQ542?dqZEwWiSzp`)@KmkTIxA9ryiBP? zPR$Bn4Ch6A*cF2q5G!NC>+gyQr(i4@z#Ldc6!vt%H`aCdD~&0cvpTndZ`EdBwct#)H)Ba zOLGgsgK5cw=>>jSr+WNdhUYKNw+6hJyT-kSZ^Li=LUhpQ@|tZifP9#4J@Z9g%x4nv znS?wGkpE=lRfs$%A;0&K&Iawf_~ke7b%#akzvGg{+Q}0}ti&at6{qGEyV-Cuq%i-wb=TaXW6OD_qop)py4|O43m$0%puYqw|nx6ML zyY^-2XLTEzk9kV^!3)st7>|WzPJu7+AAoHN%pn}WvoEjzOA7X@n5ve%=RHPK6B#^YYoRb8I0*Vln zTGyPD4@e{=As-l!HYY$^R@@ev@Qo0x-Jh`Tf7veS%GUliwCpas+FppDsI)x+Y^k`r zSgjI2dj9u4GtW7b*K@koy>@>)*LBW2@BKdW%rnnC^YPBiI|Cj+f$j7C8sA-_zSH9e z{MMZGL6k#DKgYmQG5&QFeU9Km{=UD$SXL0W30+yXtMfs^^t>79>l*5GN0eU1-X4Ko zj-pS8wgR@QX@5D5WmEf=?AtH~&$MhC*cUuG|410)Rd~l=I0pUBYyYzSB=s16=U*Xs4Ec0f)N)Zb@;yG|Q*vVe6(uM7`655_?vwSX&cnr!|NAHxU8!l) zy9PMZj_rl57kRdvLZ8=*{Pg%Z-@`LKb@@*uhb=?aSf`QiLMU(F38J2P9lY6RehgQJ zb-J@!5kKdIj(yGF_j6pE!RH)g()GIDLxSOs;aShN`5324n|7?u z-*=K>P#>PamHEMWe3?IB-(J68ryS%w25tR)yi;Re2Gw@6J&#~qJN)~$muy|hxeKZc zqTkwsu|tl>_23=8+?%tdwJ>E%@L}|$9{<__jFbIM58AtkNW)&EZZmi>*~TgK_$|EB*4-qmtF zJzr9LgwaMvVveg2{a!!fp&VVPhZ6O9Xa_87j1M|A@7g+Td=|u763X`vji`&?bX5B! zvWlFszLJbDBR=X!<`ogYTE}9KUq$OZ1<@w_9>K4|Ir8I`&f#M8rM`>4)KActx(|BT zhj+Sc)ZtFiBhBh&)En1313@(rywPnvV@OzdIxG|r#=CEnYyz_*lgId?jFjBA1`t_vov zvV3RdZ{}dF1=hC&r|K}w2M2j6XyfxTWq?9uM8QxKu zXWI}j#|ALYpxR`4$BtC^k3fF)EO;O5lhLtyKSpEhJA%B4%s{{O5A-dv!Ar`6GYEZB z&{97*{bpqe-t~JCAKo?dsJ9mML50@;Cx$Q5AHchM`L|~ET>$O6&$CTWRqeSSZK;YI z=|cat)WLot?AJ_zO$E`01s6Mq115gj5pBI3eLu=EuHNYmH3s?u>z(d%^~mex9JA53 z&2(i|dRBHV$9Np-j%?H$ftH-<;XL%Amj?>EHlUA=bWr9p)aQ`~^cxTl{uZOylw(k_lW zXJFiUBXo!~GriQI3ctw7+mARR^#RNyjJbXPwyRXxV>+DmPHq|6nLvq>dj#{0>kC4V z@BA_k$HrrMOx^V^3ly|ZNB&LH`AQz6DxAZ9q(6)4#~Et0?}@*ODm|*jG9Fu@U5d zU@YDx!B^=7>s|t5F;9*#m9<=o*}3IEb>rJPlW4 zjTzz{h5DZ|+y{R*+JRovrZ7LKQz=I$ARp&_v9?3iEtFaE*vIiB$WFZ^dxzSOcPz&1 zLwRBvNuPHj+C9kRC-V{ux2Jc#7U*Liud7JcePQ#iN8Y`!M059;`XY+;5URXluJv3F z?6V_YUYY)$0@{_XuWb9+i*zu4+Ai&O>(x4snZIn~S^rGLnTe_mdLf$2a(Dpi25C2e zpW+O4)U!-G>)Icmigs6(tNr;FwvR?xPZ_}V7DvwE+Vm%Q$439Aa-FVMncgha!#)3s zbLdbHlYaI9;b1v*Jy++oCv#vyc>TJQ6=O<|l;i!W^6t_j!G{8Up0BRM z{$8FS2>INy`ESC0ooBJ`73G???`-~Q zfj_9{MQJDG(Q-e+S!MN0uDqa*n5OQ&Xm=QTAs_$eFpq+A4m-ORiW z;~ZW)uccg#ckw@cIoi#~rR@2nfx_DJ1(C)yU~dC8B^?w~)xKE&G?`=tC^$D{py zG*IBfJhaMB*hCM;%>PhbvJv%>&<3F!=KJ?B21peR;FQo z?ErEZC=Dvdb4uA*Gv+XrJY(4iv{+JAhV8ef)?t2jOu0cEu zPo2(ea8|yDI)!pkulAS=pR+z7CUXA}viOeSOi86@oQDZ{9_N_vJ5kk#k@`P?^MhIc zJGbioW*N#|*J5BM-0%K6+WpVq#ddAf4*jkn@u>FgU!vW1-9|fD0DXFfa*Q+HPw6Q` z8;g3hd#ckNMEx0=hAYdWYb?nQ$GraCzef+#HUg*@*iT`-uXvrjbOIzqNbsN+5OYf*l^MUa_ zzZ|%vLD?PlXk|FNjv72&_mMbP`~&FMuB)l@O5{1^FGGK)C*S$Rm=^iwL5H+M@}^DF z)~6X;mwMQLyKaxmps)6qblZ0vw5$spl*t~HDV7sepYpwg_Gi*%r{VNJM!PxZ%zhf% z9n>F+);D?L^q@sgd9Hd_mp95aYG1VbYlzQ-b}EQHZTar!q{io2orBSCrX`5?d)ffY z1j8+UBHG=6aJ;8Xq{+d35d8rMeF3K@IxSeZi0>>b_hUTzBRnHrg!OAC%D18O=Uthu z^oTxU5c`UtY9*Hi`0cRi7$;28!K1aVZxHVcTItQ;2 zLd)lrmuV0ED4MJEjyA8QGunL%;<^vEFMi{~cnhId z>H>2g*M`tG1bU*X{l}VD)i+^y^?o&G;mMzN8 zy0_=;=rqaS;M>clZ^ZLL&`TM(fc$41S&)IePPfJTx7BUY((4Sa?2_aBLo%nAWx_5u zL`!>A+E9-pO^iFdDw_Lk(6i3O`U*8J!FTmu^uzg_{PE3-Dyz3nC8br_nz7E=!$;G3S>Jx?Z#wY_}!v znI6i{`>Bwd@0>^RO$*;GQc+iSVGc^^6=9eki07c>1Jf9@&p$=`51IOnEv$@|9z;5r zR*WO6w0;$~!SOzh^$nmN!GrR#PN98~ryt{()Q2DQ^j(mR;i>;`fS$6P1TW6J1u;IV zWP;2hQw8w0|Ldsnbf$^xu+AGDFx{k+_hP2K9sB1?yv(OC#sGU@FN~A2Fn<{L#~<{! zu^%B_WzfG5<78n=#y^FOcG(K!`zh)u*?T(Uq1{pMT!S*+9?a)pue(yNU-0uCe;i~%{3ugu4Z|YzpE-|f&q>M} zH>M*I&hYO-zcSAt^9GnN!1%ZKz%+h80~_ER!j+U%t)FkE9(WJyGPvH(hjRH|g?3h|(iuB&Pi4>HuTA&w1#0KPu&51@6C#Jg!6^X#?8-VkdKY%Y*@%j|q!9 zrCaer{M(^V${zV9bcg5bjPAnJ-L2H!wFiq}n|$5`eRF-yPf+LTXDE;3nO7MH$3q_2 z)8W5BokQI*&ua1hEn}i3Z)>~<>tAgB>GgwpeQp@}gZT&4W&P)ZWnLhRbtlvj*Pd`5 zRnMR3IbRhg`gK0U$vL|=FTUAAeaCfo)RV|@laT}K4`MVv%zblSk#wn9Rh;!W^h?9Db zVEvL8b8fPxDTFg>+JTJ+CTp6whPM~rpK?7@ImQ{w@Xb#M_i9Zq&is%$$#_}A`a9S^ z=P2_QpsarpV-6_i>tI*NtGD;x}z;hjO=7i4ZX1fDXV>r}5hiGHbCX93$e88qvwBCrA4 zBikXCo%YM|Io;sbW~=dA59XxW5tqyfx5K7u{&Y6R z7ttT$Oz*82zec|I{w=~r zP>-rI>s8CaImF?Shot=*#$AYHE@K_3!JYz<<8HXA39f@4ri$MHP1g{QOegnb3Ic%*Lc3} zx1SH`Z2i z|McqmChU0LgiXblHv4MonnM-Mj&oy^j%8t0Q+=)C)LgRyJCfr(Utee`;_@-{ikjNm znkH<*T32c4E&iV>z&$t^In+#X{xfplBQ?#{Dptx+zf^hEChXXKyrQaRRaGTK{w(}H z!32C<`mCs}3Nl?W_efer%Lu1t!%ns|ItgS5%RV@EB8?1w0 zI+?=Rd#n@7RA~G;vB?I@u%7viKh?rYjenShRU5w@cCGcCULSs&>496ozrb++6KQ(~ z6?F`}$871Ym3Fhwd~t`j z1mxJCJ}|UcJhOG`azVS_P+6jTfN&n+}2(8oWD!F&ODGFH{nj{a0{LovUhMH z_p2}5>D}ci-Zo(Cz``9V+fyGH^784xnOA0UpZ1qdQHp>9Ac6)Ez8JquFB!ouwVrys zPfXl|u;r4MmvI}?mc4ZarzG2VjyayndTLsEq&^{{nF8|}{c~Fv0 zZ7OBpaTq@|7|LB>dd$B2vzQKUyMGr`P_)al)BEt5R|2oSic}bF3|}BL+f#R>Fv(QF zydjD#5F;BpM=6rZQ!(cN=Z1NZ92y}YpB2CaO%L~3Q zP;LqT<2KOgna_l)3@FqdZ72NTlWqpnKX-V;6T|mjRk(G?w!y_6!#amjc z^~xEY^upl{d_odF-8qmU?iud9bn5iWubg@H=f6lupvuulCN4iCgk##%ncr}<0lJC! zO)!|U$-?0|PYm2Ups*wLD=O!ThUavo64B*%fuSvB;90|cPo(Zmfz8LxX2=EHZ1XcV zQPh#znR4e=@0`=cMla;snX=VO-g8fnMYv~7ILZWFra$4`>w(>>UB?~-^n!VQh0hE1 znGJ=so7u{4ItO*6J#^|NSU)s=`sLvyv8{#{6Bu&pr9xPQCI}3jqv*koa!*DY=?>9G z13GW2kc})wkC%+RHms==a;f!Z!l({ zb7)O8Bp;2NISTs(x$M8ZnGEcFEZ*v!b(*Je(7x?_oPQeWCaUaet%-ZB6&}@GQD;g= z>V3!uBq)}*SYM~yDXsex-X|vQy`^ybgdO7xx8AhvM%Jk;5voG#yt!jy(XQ;B!*iF3Lzmi6zdP0M znrC=$(*)>J%1LL6s_|7>pR?8b;OPg94w(006ULaX(o3ho_D~>{FIC=9G^m%wr(Qw< z(R%UWagU*$K-zd6L^Uhjod7KRD=$IM8#Jm;nav8Lq;qJ;u%aDfJf8>{W01&VhHmTK>|hSI$r@Wq+Rt>pin`;KEmD?;JSq)j2x{ z&Utmo&VhkfL%eOE@BWp?kn$g+ESo%BmHFy?`ILb^n5pEdWwhwm_?KVk3^b6s!nOp`R9x$>o-^!cO`K zBzUohq2j;fa~fCe54=+ip5xQF^z};&-Y{O{s$PcoeuM8YxT=da35G;XV{h(xSq6H& z`zfz+w-V{0oT>o^tm-ga9|q(BpNWQ4?1i@}(#V@3Lr|IOmh_|DB;^zEX9EgXsxQu3gUepW!iSrbCgSsC z68x_XAE^+f-aTsYiAKR!OuR1{+&4-C>Kzi^HerpnZP7?gSB>2iCIOdQO%JUd-+5;Ex(W!S& zT%Sln|NSKRD~8YUaf%K4z}j6j_z8pWG57~b_zXpppGa@lC&76JQX={!T&S~ z-jD=emjvh8MTz7&m;^tP1b-n3ekKY2W)l2^B=}%-(Gtn&OM>5?1fK(3wHII18LQr> z;e8+peXXJIxkJ;p8hiMf!Sny5Kfc}IhYa3q=>N*#6K85by_3TGPrwtU>(wOqWy7a6 zp!o###qpv`%5#7a2UQP%{wv`wi|h_(a3M*5D-u&oOw|;H?ISc-pOK zsco*&hbA^RR)?CZ9eu&Mi7OgHja716*<9b~G*y@Jz(bto+ql|UT3NQdYITf`Vat|Q zIy_=g`73d-Ze#swr@U%uePdM_CWvrd;iw49DytCfiYiQr89)waAOqfSPHO-nb zU!RNE(ol&*mKAZMeo){vG}c#CH8nw6byRSfJ`J%+q^{?ok<^%ZATc>OXSrFaqP7Z? zUxuc!rA{Y@hetNADqB<4SU=^q+on#v?GvX*DvjaL=f>tT93zRTMRPi&!d058YO7X2 z@j7Hb1*=0GdB|faG^(F-db7Dq&88ZpQB8=JiJDayEnI($$7NF4{RkJ`Q#5x`e@IDy zbFG(K0zv=Q9kLj@;7OCQlPD|fvojS3>P?4X#Q4EvYBhk#NbON`!P?7=t*lwP)Ot`; zhvT7z#|rCgPUd&niY86kP+wc?V7_&gQ&xtl=DPZ_+WHDLfvca}nW_<$qm^|{dWusY zw@DE><5?CLTWdOgU(>K^8V;jg-lPgbRdYkArcs?#-da{yUssM;mus`uv8YrlmQq|) zOq#1e6+CxTOBjzx-8a-$wU#{+!X&!Ud}S5p!K+n~VK!odIvx+RwUQRBq6jr7rj!Ix ztEx09=}q)YD{-i*4N%GUz0$KK?<1k*RV@uTIvi)Ls%SAMY)s4!#*w;X>ShgIC7&H;fesL^gO-Z+7;!+81xDBY2Op+>B*QwfE^N1UwPNgy-{V0CmyS`@= zfXq@Sr+M=GAnHVnT|P3=-UU$|Q>%EhW(h(`pbLS5g=22a(H8meiM zdntiSt8lV?8FJN}(OX|vL2Yq4ijY({H|ukWW1J07@LGW)EtP)*vaP>(EF#uvzm$Hp zWQ7)JDJnXtIE^Ks!V;5fYN)EJwC>r^)Yhz!I+%tukGJ=uSjSrvkuHANu^{zz%j$VZ zvd(|iF!r-$Rcz3dl%p?T6G{6Xuh=wFhDAKAvn+n{0LE^i#z^e~_ef1`Wksm5vP^YV zl`W&s%u4g>$`v zxTh`r3j*TG@k~1M;ar2bpuwp(dL?aP7cPDKPJ@qf(eH8LLVwxd)X%LFDXw9RN6`_N zyyN|Y<^|SGZ=Y=}GLrr+i~cqO#${rBfR21_*IxBMF$w;lh1-1A8l3u>YVp};Lia*D0;*>i^8t)C@$f2VWnN9Ngy+xj_S(cAbbgS*SiS%bUF zOEKPOCEh&kRsVcXr(?X+v{(JN8l3#E2O@E=H8}NPrdxbYSa`mL=cnl##%q@s z9)Lwh+@@b^;RTvR{Xd8IK03;2UZvIjF@sYNHh$U6N4oWP#o%tewGLJ6lsufv6W3$m zGX%udZw7uTzj;+xPvy)};x?bl7QJ~@SMcWM7t&7hR9jy~~(F^{#!6~O*UhK0!1BM4LPh0eb7XEA!95d<4 zk$;gz|CWUpTe#1R*OPvhh36!}mst30i$0hH-(lfWh8V2N!sl3gp0V%}3x75V{+z+x z_I%vnZhO9BaJD062uQ_}V=8>=VV)JQ-@@&38n*DeE&AhTo`8H7S@;PHx9xnwNKND} zzmpB_F2Bzhoc!;z_~Scl<%rvIUbJwV{<4MNZ}F+ki1WGC!Vg)vosT^hZnry*nQx#x zHhsE<+w_yod;{sfV#T{BGcJ!^KhL->j@#*~wQ#%seB8qA{Cdv93#@oATDZ+;teKyn zocL}e<|Z1P`G{{qVlKzvtWRt_*Wwe5QDa?|h1=ylV&M;2^kFtaaFnN9d)0rBg;!X3 z?O1(7`jCZpT6mR(AGYxM7M^a_C6Lcj3-?*LZHKuQZp+_gaCiBA+M-`(@qfnP?sENH z5Mg|}FEwT0XLie?Kh zvFO7|@QoHOHqKz1E!^(^>_~#|F*x;nqZRK{26vao^zoXA=`FM9#~NJnYXP3qO)$9R zm*5jEK0!sP|B5Z#uAjpeZr6L84bJ}3BNm^_2B$oxsZmegH8|z5@e-4GrmNNBQ)}UN zJJM?5w^;N~S@>!T|H#5^df!c&i1Dtm=ucSqqZa<)&2jp*7T#mwU$yWv2A6#4LOgUA z4KDd2_+^VvP*LhXpD{AZ`85kKvG6tvZ?*8Sh3A;WlaH;RN(*nd=nq@?ItxEz;p;8@ zvccW<{E@+#UXv9nRGKj|%45en*}`SaiUCS3+_r}k7H;z?{k#^A{Ox{S>Et+W(?6F4 z4}T#}Z`Ys4EZpXkIVDbSmzRkaZnxL@7QR9URsUTUZrjyi3;()Bf84^qVc{}3MLm4e z!u_TbPkf_=KWO1L{o@w?kVSvN!tH!nkfVvn|IaM?9R{bJe9^+Y491G{l8`5wmkV$H4){v^|sc+ zZTe#tez(Q{iiO*JN^|4;TY{zc|w@ zID)5}2QpSE_(X#*F;~GQytKK3`wd;#MK9qyU3j&*f7XS|{R=Mqgt?En@JytS?p=L} zrAxj$37Y33r|7@ah0Av*vaU8pKS(nkYm_Lse0Ngm!sWXYng0@cS)ZPnqWK9f>$oSo za9Jehcj2;*yV8ZrdhJdZF6**o!DlSqYqT60sr}`Vb=ebLxU9=Ab>Xu98t2R?C;Vmo z^&uB7>#0w;a9K~CGoU{oSx;TpbMb zWnJen7cT2M&$w_|*ZGzUmvx=al%~}ynnUHdHaF^PwfGvVYC}_+u|Cq7f`yMEXG(cf zlQX5UUf<{|gWWbI-nT>LiakXiO!-0!AcYQnqIpKij-yt8l+`Q<(YPon%!Tdyhnraoo< zvuI0r$$!e@j+-IV7VzJ3WFB}J{5Rs~4o{x$ya(j8noi}DramD?=T1MHvqa%bHY#$b zL0@A3?(nzXHhtPOU)<%yy*};N|I>1F)swub)ABV*a7f#%d9%HqI7g53cb|}t5kE^I zjq|Ik-?<9Akfe`UcQRU$^Zdt;I#yWX8pL1b!6V80a&}p{W>p4>7^i2bfNDd>q&DYV7XT;veK8BgN zUW?y{O#=>$#WmW7J;J_?Jw`*+!#KJ6crV4 z58%|y`D>11Ur>h6Kpg1z;9QQ3gXhNM+$$6AL+sbpg}nt)yA)(Sj(tS2#~b{A~;{++Q7xB z{*OO?)PF$jwT5#`d0rjtViWfT>w_nME~1O01z z>GVTq)A4*2apYS(?oqM0+;QW3$b+c+4qrjJV0_CMc5a+!1oGzt=N`)0xPE|r-g;3E zZ@_&b9lVe86bn-JjoAa;@(d^L+e%r2{}DBMh|3aj*@=>yHu`&^jq8kOb5oy`NAyYF zqEnuA$a~5eT|eSQyRJbW^YAZm<`49YJyS>GylHKNpxZ**Ksme=zzM%)_8+y(8 zhAB8tE%hMlDbP^w*y9)F4to%yJz$v4XhKw1$E}{wLC}T z;2Svem-~K4P==UXTEB+<$eCf zrW>24)M1Ho#i!f!E!{A(_k7y}3}srm1~&AC!%t)fp4gSTcV}v0$Bxv_?Wwc2ZcE*^ zHFf8AQg>}hEgVqtt<;4(I#RcHrWWn_cIxiUsosaMb<5e;O9qzw{1>mjCL42|$kw5C zU{E8BW`Q6GsG}e^Z_O)bUO!u`N%X@-+^*~F>w%%p4v6%u7S9Pn$=F|{YjEI+PS4&B zPhrP*Je^xSbB6r<7kY1=;%(pdY~AcB+VSU}?ceeg?b_to`M77^?#DcfUgqX!-2dnG zfFTAO9UK7=4D<*Eas<-c=j$EQ)TTj&mVdVJGE#l=LNWhe>?Hy-KwpcoYp3$l_!I3l z!9G`_y(WmJIOfHXH^yoDG#O*ir7lwMNzWTUesrsCQ${Jb1De&Lg5?q4uh;UoB2gOd+!RNTA9BYbkq{S|W+K7vn1 zcsij^*SE26w1r;q8HS$m3dSI%7H-Q^YvFc!_ZXbh0?9hbc2&V!^FvpjO~)%#upfRcfQLQt{Y!#@wfAFLlSu&x9IJ7Wh~e& z&$CJ7IcxD@c@+Ie4DQaC3rYB-v3~*Q)@QoG-TEABaJRkXCgC$937-W?=pRf%|CB|~ z^!h0@+|ve^^!gQwddA?CbF{&DIpg9}VxFCK;R_5Naq$=W3ocyfFB+Wj@`X#>6^p-Z zCu7Z6ja$zXli*7XPX3bTjHA}Vuaih|ea7JK{CzeF|FI^ljAaX}=Ulk7v!8YB^?%!# z>j|R|Nw2g&a-VF>RlXg`F@w2$i$K$FiHu zEGK#sh+?|)p3fE-`KyJ{T;1U@W}5%UjG5k+n{S3yKmC~LaVvBDN)A6pOouu=-@}Xd zbDkHV&yVm-;`l`f7|1XTIqLROET!?bW{luiK|64ctMR-JJkN0E6cv5ZH*s-&lP@0| zU*t@g{)O8AV{({#AnKl)IqE( z7>|S(JHE-_?s^~$Jdq<0+a+s5!ZwlRcZZiYMC24w3GWlYTqV3*Ih`$jo3zWmvHWh@ zd+>~yRm~{sF7@C48v;V2Kl9k(m_nj9V1Z#MdZzwatxI^p6U9y5XZQ!_GXk>>k#>Z* zgiqE6aDPj>oAo93Z{XN{vNoXF$j>&;cJA=E-j<(JpeMrAzp3CYfB$*2g4@lsneWrL z0YNKLzY@leIY?;oKdHlQxotn${qc3N+d?$Ql!Ps4;<}O{Qk1pmu(5v*@YGg@8c-+x zq5A3*OAeA%RWZi@H4p0+>MB{?~Z>xD#hL$b0h-ze!e-!Q?&9e=X2 zonZ)P#e*uJJ3Pwv)Z71vvOWDaDcqmFY-dVE1_}I13O~l=hNFLXI5roafw>mWJ8{lB zGSk7_slT9ij??$eyBlZh`ShGuHs+YFq-0F`9e(fQhxx9BoR=y%G;d0nS%LY%$XtT&aP-QH;8#w`eAgr(8p%Z8<8*PC!=jc4n*6A z9#GG(aq`LrIk$x;IHf$(Gm0|+gE*u4A9x+*lyVNqf!v(mmHAwKR^AIwb52d-!Q5hQ zWVioFbf3d>jc@bapys&M+;uPFF60@Dhgcoq?5M~&oTE^ z>ctshWv$N25vVNGkviG0&jVVJqV2zX1d>qmr22VfMDD3+h=Ja2iyXLLyozh=-Ak7atD<6md zjqNzE?JZ~JWcV+FU)I~s$`{5!uQ+@A{C77mjDTmw9S0kcCv(x(Zr*_W$b9~WdpG#g zw|LiPjU2dk{O$u^2ro=o``z8YUhD5@Kl69beh=4UA60dvebwJl=%miA_-NTng=yiT z)JLI{g05qDVPW&2dkaD59eT@d=1le`KQ{+!BL;gm<@Mxk+CQRwR{-<-oCo~)QJudL~j( z0iE2|`xef?H9Q!W_IZ8J@GZjQeHV`|oDaBfs^-D;XJ3kzzK=5+nXlwCs>j3aaWlGa zceeb4_qt2IH+k+O=3z}5{3sV)LvR*-?bt=#UT1Fisv8z@{*?C6g!A!&unn<`qi;k@ z*I*9xoHug_?cgY6-G?~w0;_DU@YhkbRwD~K>BU*TS72vZk9$@=16$4->sgsuly!}B z=yTU({%v>+?T}$3m@B6pGCn)5(79-78RC-i&azLNjkb-rC5n21bKd7z&i^{Ru+8he zMEmz|EdBsHHmrH!*U{37-|||Eke@Zo@*BJL(~GZT@bSy{|(T87OC& z(b|s8l+?MMzpv`(^rp`BtoL5uxo*Jq6nG5sGwu4Lg`b@<#~hUa#sPz0roUL@hvA=PaL!rHGB|093|&%1yUgJ-PpM!98r=Y7v+Ux9qUuyyTcfr5d;MC`R#!r2!OvgR-w#4An=a-G2 z`cWBb?*FGQXyeqLN{qV|zwP*S<97Kj%zHZ`}b zdZcyrnm<+Cuy!`*_R25D{%+Jv@yrdCwp2AS;`^&A>$FcZD6MX3R1XZl*^M}cT7=@lSs$^@%wvpRM?6{_6*VQ}Ii}qZ#d-zvgd$sWF>p18tb}|$KkXA@{ zrti9X_wYSek;xjYGCKSE+D}L9{mQGay?%C%g!dNnwoq;%nh(EY_|f_K7e8+;cDCL` zz!&)pPL;a^G;%Q5SkTCO9>d94HO{RX&f8=TrtAFiV zbWV<@AChF8og;dmbcxnjvCgHA-0ndDiEx&pL^w-rBK#XkaMp2&==UbU|1t^w{UrE5 z0q6X|ah6XwzxsEamvAMXHc$f#4E}3_%l?MSwt=z!O(f?>z_0NRa1NRL4&t6}5KNG` zII$Nj#>C1f?q{wiD6Cs-V%m&t%^RlVa2xVRs;ZW=hHPHrtiW#D)n&NB9=0vmgB06g zud13dJ$Kqv+1oZ$Ti3E8e$!AL!uHuU*paoMpsWcyW7nCjeruX4YnEXX*-z}Pt=4_% zjaysGxB)Zva0XV3g<)#d7Z-Y2E5T$<7t^5$u!f5_*hICVLAK9bwu1WyJNhDP%2Z-> zm`79swT5zxqB!SoTR+PWovfA6cUaSEJeQ6;SbUhSH1q6&#mB}|js23(7>myYgNxpz49NGSqBp@ylJMD>1eY~0!hea0`$Vet z2!Fw4Eez$f^W`H$FMPy4QcV#QK7ywi+|4K7;KD~#F~h}2@L&@9$|UsFroLgkHwY8! z>H*Gt5hwX3xDU_iMBjo>G`QH3;OsBb`P4t!DBP2OzQLt_6Wnj`92b3w!Sh|X$me(A zVRK*N!Z(`x1ulGtxtDwvd7d_S&_#d9+*iBs9&<1CvG5Un$=Wo*j~n_PW1oVbF!*s7 ze#YP@TzJIbXI%J2gGXHWWrJUI;a3cP*@dHXp&Z7uloL7A4317!KRn&wX)avqqp_Mi z_WiH9jjeT+d2VSp-*VAQyD9vHUfRt+G|!ae`&NGS`v3MLSESL0A5~|HDSX=b%{A4Vgh5r^gkqJTTcTx9ZGr^8Bpfry(qPnr0%# zSK{{@dy)qtzudDQOcK8U=6b?Z*0Sb^>1P!w;U)cl0*vwBj$c2A5p}wGt^`YXfjOo? ze-4Q)H;)m*`P6^>Pr}KS;{@W5Q(>*532$TcyJ?pj%&or$6JF|L;Un_P{Ze=m>CbOE z4?#mnc8TWeDUUmD2Iu3r`fj%gC?a z!pTuPcX-SR=KV2izNX)H+wDH(KK-2FMoBD0@GCL&cd{Qp`dn;Ikl&<@TpLi|$o>xF z)bC&K^xZes8FB3}f8Qbu%S@f9zp;FBIOpMV6*i2pZC>Y6)5-9zWMS;FZq8LMhAih&QYNK99=$%z zImq$!RaXK>$QxrxZ?C}jtu6Q_F*F9_)LmDJLJVThJ*2a?_>T0 zWsc|4I?&=f%shS@*FK!z1{WSE{}b}&nzo-j?RT4mxjGyUZ`s{S&eGtw4?1 z-?+hlfOBjcMhEcyFTa2EZ247I>VXT_4p277`PT^MrJ2vrjncoKKmKPW4|P>&=Kh2y z!-S!8x#zd5;(s6hqu-g`=VLktdJY7wbb3Av961kJ&Or`-FA1G08OhH<{-4KOA2B`; zAUyTM`M)e@)TOY;DeXe}cx0XTK+6q!4)hds{O&-`TYpmSw%>aXw1G}^%=8@xz1HWU z1HVZPkGObscm(HY-o*Fgmr_!$vK``66e_8@q=e_;s6(_v1%T zC>?(M=nrD`$vgO-H5X~qdF7~YTTu;d&V(FXL+}Celj{dQOi4ZX5z52;$nWc5Kk9q@ zVg8TX9OuYB%mJg^Ei6j&_dT_%sBcGRBdIcu!b_^Yfr;8Sv-7xmE6 z;Z7fAXSrYRq&&}Wg*m6%%Xx0YH>=pQ(&vTVu0(UOUSwef(#1U3k1%bpb$;JYT3e^2 zqh5t}8)%q+e}U^v=h{mQkN3w?K5t7czJzz-()UsZA|2s{n?Msn+9D~}9ee|8Qpjtx z$D?FpI)8QToC7nLPs^w5)NwGy>3bh(XoGI4*Y~{xE}^bQ9qVj((M3- z!}rjj3!)BPfom#k*ynUD9G~g$Ye%~T8-6 zbGEv!#<%FGR~eVGbCjc)jYDtLjl16VAbofr!_ozR-#YH;5cVIST)j7AT>;86=X*T} zCw`pRwyLVphf|*#Fy>d~ljF^raMo5u^Q}CZ&4;t^aE_yPR}InE3Z6e#84rg6w~(*7 zzTQ_}vkX_CIb;dP=NZO4g$k!W`Ih3~E)2@eYUPoM7(4X2C8)(`<30@bEo-g@`-&>i zR8IEYxTexqzPh=pX^L-Ab7M_I15c3p6q6;UtJrU@Bp*pYeW#onTMG>LKasX~P+`Zw z&H+VRQ@5oQZuj0h1hXCH!|$Q;|mNAd!O*_ z&3Zsjq?7Q+!LtUG zq=le^fhDh>ef722OcUOpm`?e&(+5A@Wc&^p{u>Cy=X^R-O2I~d5szsddbBo zSKlZUc6jHCKKZJbYFraj>ut%r$Lrwo* z|DJsW*xBDYsB!{qB7V#}x8u8ZA{=e7;?rdUs4@fpz4#@fuSkM7CBfGx!M_EZ^2>L; zxwxm}cS6L&#wMhUu@O%s&)*sP&4ymy`Tr>i{plq5g(UcIli<-L_%N7GB00IpDG@#n zIMW+3FTxGrOUH6fd;vN?%9-bZBz#Je;ER&rRY~yrB={pq@C`}uZv$8In&mT_L-9ILm1hNnu#>9i=XgH-c`-A^#PCT?DuRH z4^=hc_z=x=l{u)Ax2tdjrS%kdX3mWdV-s+^X=pb4GFT@|R#uf`MMO*=@t7bKn}7BN z`XB9U9S&Jr!vhR0ZVW-{74@skyk3QUQm;NsRU*TbAJ2S@MZUDQrK#FFK(?XGeIO|l z5sw}cuE1%J?8WGemi*@2h#9U@57_?G5w{l?)N1$>`#v;VxJ@tZIr&H(L{fV$&MwdB zKPyLi8<#fJjY~aC{2Cop{U5gY*y&<9pd&r&esR*iat_KK_Pt=}IhSSQ7Y$B6_MGPx zg9{(&e|=RUG-nR_H|>tTjPZ{zZ959#gnZZ!1#w$7d-J#O)d$pU3uwD9Xh zIk*lp^`@jN$2`k0xTH()u?D9+_S~k-VG`%Ky|{dfp8Yd%3oP7DSFMGAPKa@}=REDX zz85Tdn@_Q67buSzE>+wb3@+(yHE}c>T+%D}Wfy(Ep?}v!FSvZ?&vvMqYQY40fi%@*Ee;kKQewQ$=WhNbDiig_oFe_^b<;{@e>LT>5Rfkeg2UOMi%i5;iXVp)NOW z^dj}A@R5Fo)Q5sgKO@b^E4cJ0KEs@(+H?1R+rAIgCZDwy<8wH2pKK1Y$23Z^9|wmO zsB&SKX&BJPiJNN5pja;}gfT>WOt!_)$?%c%vxet;4SC*aB{s9PsAT1g6Hcdyp7TCrhUj@#tdWR8%=mw<0B75e!2fLJglny z0+?&2X%x~-gv>vNmGF{(eC&>!EV?iTK$maY0p7A7o5^kA%$ z{0lJ;mF-L4f~d`0j~;_edHhZ@XXG3lk1^T_C)9U@n=3%iaQiTZDq$;}4Z9G&GmP(C zIF5S`a*W%Ydc+=|)Z@E)%yK54@f#G5M{?}74CCO|{uT$PLY@$Y+Oj+67xa2^rgJWm z{6lL3t1)h>{K%`#!H2Ce(TB~LsF^1uZ`cl-03|bJ?FFCTjl|py=7`7-#+lc}aeI7w z=z&bZ$FM&s_Qj=s#v=`+=iH`@y$%YW6TkZDKid?buaYdr_yNR=*4%2?Ovx} zJ~HfYO?({RX1tPjGKNh%$#}uv_b&2`X~kIfBoER#3VH}*4rV{bk$tcmd~c@wVT{@H zo@v3H@sWKPw}-yfJe-VOJ4g%cP07dcciNfE$5PLden~siHWG72l5bgQ&f5ntr-1o| z0&kl0VrYo7r7i5NtjxS~O*ZBRR5~zMFy8SOlzTnT^BMAM6QBE`=NnU<7uUhYN%!6A z@_h79UnEU%f^%;r_GQK<8Y7&{z#8=5F&B_}@SK_t_8iP|oC3}xh|R?1*0x8S&!Kz1 z^2g?6-E=;T`Tv`h&+&9}-qCxo!^~Z9u9iHRPqaJcE$vRq9`ZNC&L_+vXdA$HV#0&- z2@LN?da>`=!Sl*aGL)T=5BV}*$d~-==X^#QJ|hjExA9v{=%vWPKEU7GxX^#s!NxYn zS?rR@uLnpdj?_OV(3iG-JJJq!5713y#)1(Ir&>zH(<^NbH2QyoKEV!)erj| zb#T=>&7=2atU~}D=}F_J<2~tFjxfQprPuIUKiZ#9J3ohKA=pt9Y@4*d^p3p5Z&}Zu z)b;EI$ff6~u2VLl_+cu5`4yY%9M82GdX6*uYJcC4O*!Lp)~9Md)S_X%?#5*82brO2Gha|e_{AA{Oj<4{OI4S zId46u?EyXcqi#f9M%{3Y0&S`TX(vCD)7xIDin+N5teTb7g^Id0U2I@rS8QZH6${gOwGPssvT&lky56{Zb7M;g8 z!)2hYM4Lo=E5rBYxoOT8-ghC)eth>o6W9dYV~)5KddK>hYY#q(bW#S?19@Hit{F64 zqqpu7d5(SwmNxGJ#P!5-r8}!)UG_{FxVRt30b2 z$1BLwHe6rFI*lL0UUd6B2E0Ze6dSbTErJ~|?lJg2m+2rcrp1SPhiU1-{QO(WPJVQt z63^HU#Orkr)-Yk+4cbxI%}FQcPPUB&g+AB<^se+a$jJ-7S)}@2zLREkHWXWE$E-{nb?8t*L#6$o3Q=m!&elr-vs&l${pXdagY;r{E^gD)m9g*V|$7G zOG!ifj6Ty(u-|w&FvzFsM%qV;vwj!b1;$I;RI;O7bG^cN^m~{me5Q1WK7iKSPo93^ zV|;Ipd*ad$C?B|@pwK%pCI{mmhy0T=;TSo>n8x(t8RM^T!k>sg0=-KZu89)=%PK#9 z7+b5tvMTj{C(5ZV%g({}yHGb?;~d5})+aNelLB0Inf9vs8FkM|*3o#M$l&@7jGL71 zy9;Y8&^|R`Z3pXSwtta_oAR@A(f+aQp-tKk+n9;IiXZDhW}?cgE}ihd=dw3TI@M6C!pHK?AELifjOQd%rElcz8s=ghJOn2F+Z~3 zjh4pybAK1JH@vYjDkgZQ|KBl-cv+xgIFvU=P|V@`J7B(uT;F=|vwURu6OC z)W?thi?XXWA9%qI*TYuZCZJyjzG3joLOsd%o-Xu7q;6urzysT{d5N9&_FDcmXIMWr)SkzU}`$p`&L;X?a^&ex8iT{Y^Q77L*dZ<4qt*|dL z(&=Ux-!SAgcrjcMbsNKs`V8r$ti7G2Le5P&WJ@-au*64zX* zIH+gjNw#Ts{xe;s;N6h6a`fSf{Fzs<7s$Uy)qBP*xE>wuFPM25y2gGvA;gOz`-~qy z9LhiD^=v8w-UWTY4z{$R-V30g!#z>h&!HS&f_{AOM{~Jn3Gdl&Lwk?5H2fV8uFyBi zQDI;B*U`i6Xmfjq`KD>P^}8|kSvJVqhxNj-@{$W)JtvEg9DSMjg?{spv}s}VkArVS z(LWxo;(hU>==R_{(cDbXO8MD}_^ws5>Gq!Gmd{228-+D`^p|y{9${I&3K+|jU7mh} zyhp#E`$rU91KKAaer(~BB?lX^FVb?hNm=Q5N9&E2{uuP3NgEf2 z9y`!jhQ8ZT?89<&1oRn(j^Q7RI+1o4fbM&-t{1Z-+WvkSE$tcYY+-$-+H=qc@XlR~ zckXPwbNlelU5&EmK=0Vc=f#ik9!MMfH}ttiA@3#4uj8J2r%q{i*~T8^`Ac|?O)k;T z*Lo}aFuJ|#H__aG1#XvzGr0dT#xU4skstHTcP5(0yz4~zu@BZs?45)5ee9(%&gf0- zw|c8r<(DOp`#9S6bE+=YYk;u(C@__PyPnaYU*K6 z%4pRd?|DDk{f~%~IvbZ;SWtdm_k&mmu}))sCNerN>3Rot8>`cvLRzqo)$_FXX>502 z!QNB|%X{SM$qUGbLX7+QotZEDmm^PJjvl@MdAKIDHzif2-H-QN5A>N;JuUw}_{C0q z82j-*&v&@2+x^dD-z>x>`e*&-)_)V89~8F9k zr6s`mNI7%weEy!f>K^-2w9*q;aL)pp?(TZuax4X@^MzWPtFg+VrUGA0*Vp-0R8?S^ zWKGkGCSOxaLqmOIb5$ks#UbB2aQ!?P;ks~EDeEU^-ko|c6%pa8Ayd?H%sKVVzLvVG z)&{KD#G1^8`i7}raILCjaO^{~Ai(RQz@m9RUQ6dKQuny}aAad#iYbKgJg~5o&nm0x zYOrQA&|iFf%3V=a%f+0=xt{Blo?rCcC|0#SeT(PE)({rS8p3ptlqhO6CgwU3R}~glB~g6uW3CFtLe0QX z*?WSt8%?-lyxMCP7sle7z16$u^aMOUY-npWZG2DV`1(e*uHmeqOEp)@dD-~W%rzI+ zR8yqZ5;JiZav5sTR`1*)rzs}ZN(P1&pN=Kj$pPsM6YhczC+j9VJvA|z)m|JbFlc=E zHJC7d_(iW+YuV|+@>s?~-FF%qqqm$V2JRi8RUU zA1w1x$I?Zb8q-8p2}ULk-Dte;HnJ4FZEfw!E+4#THMod&_nSzxT>>&?J@WcV{3lg)BQDm zq(5VDk^iW{ON=1Tkr?g-ex#Ru7*xFj>^BC_H*0HTu3N9=@HlwyR!-6}0_i88YO`=g z**+*H2tHWTt1_;=PNFs6lR=+ozn@!ybH5*Pe(~U%Xf3$rV}!J5=}okMkEZ{x@86RT zIa#;6-K-?|q9pjzBzS8Qe0>spYZCl>N$?*e!GDwl|7jBZ=SlE?OM-ux1W$wAC(`egHzmQpkp$nK1b;FK{(~eq_YFxT=P#1rZzRFr0?vJ; z{H9=UmIBT<4zq<6e0l+TSw($a9bQQAqQj2;RP4sY*M%~^18Jb4s&Q$36S*+Qg?+8kwvG|LRe{?;5Oc9-y`OBkUDcXKxl3k5p}T zR>t!nX#!>S4a!p0bAXjNXtL4>!cQ?4RW&besI3oG7S*@ZHN##Np?Ok_cl%_|bf`r& zYx*;jAl3tx5$p4ZicfqHVShytPlwpHk;wXvLD5*>i6|YFH8+OpnwG{=&`{?3R6^-i zCm)5VqFO%K;I3=cCf)ku&c-rj#d>`ptAdeezkE_B;5y9sxdzzAD-BM1dkuWG!MS$Y z#v2UIwffn{&r7HA3m@r6?l8FU5uE)+I-!?3@hJ_f{mdAz;D-#(HP3du>A0sOK2Cep z|5ytjZ{a?JGu{anKGERRkBt{w^pr=&GfG^z&+wXOa7nMwFL2>PA2hf-UD7WlZm&gu z*P^%a$!K5cm@oEP^aTcYr+10L-RZ4Nf_EC6^4zSWQvb&-e4>T3J*Ff5E!wO88w@V_ zF80uDaM7FKtx5PCvT%FMu*b#UXX2Lqx`e;rrwqN@o-vQ89Obw9XQpag7W$42Sge0=5=gz|7)SDbvKL3wOkzR_U1I7TFHf#E}3Wal$k z6HfdKLX4|@Mx!2~)DPDt;S;uSo6lwoxB2WaxahgW#J$JhqG!RMviRI;$@!dx=UDg) zF8&M5v$HP#f=4Vq*%qIm^{vNk7Jl5q`3^76XI=p%T|x6;g25$Sf=@I!^^bwrm0Dp65L0InQ~$=bq=B>oxi#8vaEMKdIq2Xt>eKeIWkyy+W=V z7?<+4g*}3dOL-G~s)ycU`jCfS@R^KLyje_3w--Eog#R`VAHjd+q2I>5-tf>1evol* zyipII7Upx*VeHh$eIWh?8opS=3pKo5 z!$)d3K4GX!(shLW-tpiT<3|{m^a}kk4=(g48TXc-iEPUv@!CiST{kc;`~{!JxR=jT z4<8vX+8#cFuh94uxlyX$ogO~bEYHgxK7zL=;ZxbyWh&_!#C)n5mvjkU!#Jf&muHWM zPdm%{D-R#R_a)&|bBP;}_!lz|x?vrZx=7C9u2cQ4VB9-iJ*@F5(dhg3b03I*w{pd} z=)r(LUGFe1dJsIS@zM1#yuTZc_}}O{)o+c4PtkBJj#QV#dy4&bdT@*Jml+p%gudN_ z3;iC(NuDg`LAR3{f1xEjz#kaA?}HZO#OEd=>dY_8^?bA@bdUi=mWwQO*7LOb;&KS*ks_eAlS;;M+L8i#@o-a@rnTzKg6(g130^ zBm6vs@9uXNe!y+22M_bJ+=X7`d%{C6{C9eANmtZ^OS(>aa7kAh>qFudeFi3@tUPW~Hg zng5^IUwI9;1DyTw@09XM|d(s#s@UKqAW{e|3Q2wGQwG{jH3PU#48@0 z?eeJJrHSX?8lK)oh$k0=IA4i>UmS5ABEP`b!jUNb`}pOjngyox)2pn6m-JH~MkM3$ zr(atJxKB@e5-i~bz71sL9;XL}dosVQSsq-%$^CBli(4oC2mNJF^YGHn{&kp15N0`zH#q7BtJW_dmXL%5$%uz6IxXuGkB4V7nQ>-o98L4L_nGY%_Sh zcgTFP5`3<>Byyq{JcwpE_z0aV!!1o;hYW}OJ+>ZB@3D8qktGLK7(MoWw{Kw8_b47C zW!3AaOPXE>&0*~2`Fh{fz28ksT}5%=Z#Dj4qZf3t4XiD-f_au@gP=rJwSHF3sq_^eZsh741i`b?Lx4t)}07 z{w8!w&*izhl>ZNU(!QX-f2t!8RnJpF?>}ALMCsjyHL#=;u}Q!*N`@c0OXR2Qmv9E6 z*p!nUE`=wY=!p-~+w7$qkzwx-G!z^tG22i0Pv6&+Vw_aEmbh0e{rPhgX2t0*9iZ^< zVO{L-K8^cRrUsu1?AwGep{9WSixWg2Kv+FKl}E^f6{n{)C5oHECQ1w0^!QINOz8Kz z^1Cmg-z&6c_laBEGPk8TSq+!<%iNygm{0UpHn_UYG1-G-u6gSxWxiIDYuP}fPT4}D zPS{v8PPW3>x44en!;qiLu7JG--ABO&1;g*eh zS6zFPUa)CFS$UuM^#Ko*lV$ykx~AP@BV<=K<7{kuGkCdc^apNT{^X;IXC~@oIc(I8 z*EX!Ru>2?NgWZ-|$M4$tb&CV%=9;h-CO*&nKEL&M&_UCtv61?}#q_Ro-APc6?_E;VpH)zL$c9 zu;{%I&R7-or=Tt4uzhx~75)-_40H`0?$yH+KdS5I&J>64-OGmoTVdEhuaiCJeOsf3 zu_L^;zzM=OP3*HIpC5#tl#Mm);CJ^aa`W(=vB$rOc;C3&-x~f&i4)FFbtpV+FO?0y z8;0yX2W;K_WI;U47}yfM@s`;d{u#myOjR~qt}U=zrsC}q+3_0Vu;;k3HS=IP*15x$ z_VLNB6;IyUHVgShcJtK6r}o3y$H==`$h#HKn5`8?YA@QOeZ@dO_9Q18g8o~V{UpU% z_OleH;>q4^%Mj->$VzE+&q#Im#4ulW_2fhS+Gw2maiKAIyoq||mH8u-nbCH~ekuNsj*e3wTeaW+$UmQ`NZ)m$%=$%y!x_XKH?7>?VY+Sf4`5$Z z{@mmHH^6__CqFq+uk6?S&2zSd5OPum6 z-2I+2VGluVK*e(Gg?!i3)2H0^-Gw-7dR1k>xa3DaOmQ}lUD47jo-fe>UZg?PalDOMf&u3dr|SoL#H~gi0p5?Vu~{yWji~q<%H39 z#o8?Fp-pFm-v-+{)0nj$JL&F^UUCF&{Qc`KJfHLjMr93}HPjeXKGfLRabI|#ai#@j z$V#=YYso2aY}nIgK`z)WDcyh1H!|{F;JecAZr$DYp4OJx1x^cWBTx=UnHrr1w_$8r zh_e*twxHcRpzNc&@5y}``ZKe1rOFe^r-G&Cb0e^)HRZvt5#|u`&qRB1Nadmb=r=#c zehJ9KWck;Gwy9-&ffEfFJDOp44BJ@9-G9`XB}F)wy%>88l)%<>N-N4-MAd!pE=OEc zPpDixaV!=hc}SK<$dUzFmVqZ>RHg_o0Zx7-<6`(_p?@PCmJc+X7xA2pc8Q(~(KcnJ z`Br5e`|1G;e4tlnEBr~1SxPrX^CswWBjgRH-94`${hoQo!SeeG@kct%!o3227IfQ+ zaABl-Bl4vkW!IV8qcw=~yZx7FBT$C_TA$WxKN@`Q$gRd117$hmbo1TUyo-0QZ8XN^y!7uS4)Xjs zzR8EkHW}xb?;nVKF88~Bm*E-Zd_U1pd>daZac~Cpek!9A(hsb?4Rvo8;+uu|HX*)F z#P<`lpV>y?0{z8*4lI2O?A+ ze~SE=gE(n?*72%8(n9>p&<+5@y0fh1q`Qtr?^JQRZ zsJoPB9TkDd-FQAtG`sPE1- zvCzbTxoTp1#;WE|9zD?9r+w|e!apDWlt&*O$9@dZ!IuNRRbNgYyz0xJK6-%i_8&o0 z1{%uC+dhhgz5~5H9PqDtIQ_C!d7z>4RtXxtKU96;3n?lc7~hSuu@_UA>J0V`SoYiW zHrRhDyI>h3htW?4V?C}5Lw>z}{26@5jJaO@hfdTrVtkD{i&uW*_=K9uN(+`xHI>zb zjkpfabe~j1H)F)ano4?4rto7&jH{`KDzUt>tBDlQnzcf_ZAUc&iqNM=D#Z5jBh}mowt}L_e`vds?L-scD!+Oc8MIkPKmGKB7JZU;$G5+XMYn8g$DLvzR z)+9rjx88Owm1zHbal7A9w!1;yJ@8BVC|f1ib5S4_>mBOu#vNr^nd_i*oMdbZ-SxPO zY196jz(#C*u+hEiG%S#grgY;3o3!8>Ef1&W%!D}w_J=5!Vzwg>Pf5F;IzdfjU-GJu? z7N(SD_@3&OT3VtGXD-mG-0xT)GXI%i-%b8oNpna*L2vR&cu~;*PFoe4(@He^MxPSN zhC(hWk5rZjx7bUSNhV5ULy@KYcma(ti_>E!!E?FvfB(Mu!@-yG+j~s_K>L*+#0x)N zlpeb7z#rkq7+3WJ*gxPe5g(c}OoTtge1ZWuaP4t##*?@wqF)D`;+1a)Qhs+b-j`Lk zh57t~@tusTIsxoI86U@Ujl$<+#^oEtNIcV(j{Ku|!%QzY_6<|`O2$>40R05uiR3R$ zg3m~TmnXq#j+*4z;}%Fm)fEyHryt*s)!_B+x^~*YeLR-H8uQ8*PpYI{!m*IMf>sZE z7Bth6V01`T4Iy4t|10p{ASQX>f0AQq#+lwq*+^^tgnLZ4tLw99^2T@nUBT(Zg=fQ=Pp8a z)is-!f6rFyj=RJuUVv5dh7l&+PNw(DzlXbeuRPcvPhEr$iF3yqk|g+I#-+Ti<}gbcmvSq(t?|)5 zK^b<>#PJ?uT=*Yk{<8K`_zQkY<1?mFzjWqftYgUk489LF#6$oLAAmFf~)##i!9U2qv+E%ngL_-eHW zm+{px4=&@MzhN!M|H^&oWsNGUJ^t-mo|CQJILK=cO1V9u_i<7cSLgV+{R+mt-@n6L z9wi>Rv%2Lm>DrA84Sy}iKR(XUbx8OZJrRoh0tY#~)CXbHkJoZq0`OhJ$^B;F;?_yW zb9fyix0m)l#<=^6ljm~yz8(*eUkJYh2X#R~0r+ll#n0skDgP*}gdfCoh938M|ou7moTqpg39;YA8+_8K|{%Tm8xKN7#(Y1x># zyQmB!tUqXOFD*SMDlHOz3x}m4A^lNW>5?`fS)ESfh(FJ0RE6uOF^6aAB4|Ks%E=5AS-*W>Z&v`^}D_*S9Lh{pFB!yn9h zx1VwR?Wdkw+m3x?jUL#Gu5$3@jlN4)LHTV)(C%*!G;)olX*2STjH9$KHLW>#%XjI~ zEUX(a@U4i>dzQ5ZvQMD9_o#a=IK*$JZ$AdkSf=xOX)OU^CgKYFhV;$`4Ts?# z+{hh%EHl@}dXIMvkFOKPxNFBxm^dlty4<|-SrwI4voEx9?yK@1nt5cp5m-FbygWTq z&3#E-I7R-2e9kN#C0j^m$rh^jxA*-LJ4Iqq+aRn0lu<>Cd>R&V2qpBvGxT zy2>xHTAXg1;H{Ykwx*=(TzV4N)Nl#uw&j7ij~+5nALa5-)^~YZ9+BtopRXPT`Dy-B zE|u?in20|qBjQK*$w_czvEn1)TkxzdDy;4tDs6p%B3o5C_S$h1$4xTGhXD0B(VYn- z%yq@5N40$)$hWMzYB3lOV)pc&$gjc*u^6ZKL>(Wg(d&6ZeHL9rujAWYSlN>6df21k z`uxLaRw2EI>OjX?`sD=@k)GNn92#Y4c?YS!jqqV>1B!VWbbPdp8WMo_=y}r zc#_*Yw(7|P9t(c@CE?_LGd#tu(_NKlz?6VC+56f!4&S0PgwfLTYje~f z?{kdpWG$MoD18d+x)gmP4)fUzL)$G_2Hx^y)TuvoTijS zhZHt`Vfje;ysCKbs5b0zF-0O}nEDiVeBg!@zS0-O`HiiAcwR&KEc6Kt3*CFQxDxjT z$=+tiD)OpooRACw-k@P0AzHb%I2Hf?vV7 zw++8nBJkXqZ5&P32V7`)=>w##6UGwW5`ga#zualB265}8OZ5lM?WMhg!+V>2o5SR4 zVaX}_6ZjT5s9y^Tz;~Ie6Frmu6TM%PJl?p8#ZLOcWwF3if2AKFT<7b}JMx!4bO=3Y zmpA>%+VGJq6!lU1RoLgTSc=HuhclRvFESy1N87V><7STTOuC0!-)xvvt5bI`XeS7)8yKBY6I48_7HVoEn0LYGk_#hf}#-!N# zU}sY&oLcD6+S_HRKF7d&^ts`7sy>CzJfXALtUw{w%$uzfapne{og(L?(7ZtB#XVZ@ z1y8%LvAq#{_c!{@Rfw~>CBxYM@fU;6B&u?6c2ETEf)^wL+o*{oV&i{aWLx1D=ygoRmsz)%-?q{^s_Xs{*pW6QA`Wu5! zJ<`v(uIs3+C94}(~mXrI18i9Kju^q#X2A$kt z1RMeK^|)`b<2}vPX>(us_re z3WK`0`Y`f~@@P5ovjTsG#*n=@8*bIc@rJVwc4T4ZOFUJ%fgJ_eZ*-r(arsid{}jBw znIH}S0SxEGK~6eL(8v>g(V1j!dWRsr?zsfC?zJ6rFgRleXYdW#N@YvYK;}3N(%J#p zsqBzkn0ImLOe8NI>4fUaXXzxq?iO}F6hFmTexlSVhn)UPuPg8-D7R zw#Nn+I8@Hic7~P@EO2Pux`}n=@pD$xoRVuh6Gr^Tpkg`$=2{c;ZDc1z_AjJ^EG|2A zwy0n`dfC$jr*qOs&RCKEH^ZR6GfT|YGeu;x;%^-Q`97XObv^(a6=SP2H>Gtj((u>% z)Yh`gjk?Rz>8v&*&pcM@Y#eAhuM9RFGksoOmN8_!nLZ}3{aPdRZ;-j{O4xvm#kofo z+}FTf>>Aj%TnYCCoG}D9$+;Bsbs|&LKLoZ71+Z->L>VhW{KYu$sRZk^VdH?Z)$T8Q ztL$Rv24Uym%$&0R;6I$!<>Tz3OO3jE%xPwgfo;`u#ZELIb}k!=Nx!S{7ooT|U|l`M zm0>im&4ztul+UI^9Xd`nIlf*umjkNG%@Q!f^p}Z+3#X6K`4z9_Kl?Cv4&_-1b4OsjqO-|TeWVK`_j9bY}%Ga%!Vn^hZ-xumCK6y5AZaWnzN z(W&Afn@jf`K5Xo_J$4iN5Tff5j6|^p-#9!qFKqP9DZ4m$q8#au-D;@yER*jw~*Zl#cdeu}Rd187T9e+?G*Tou&n6A9WT5 zop+IEqUV9eGi%F`SAJvp+8FT8TZ71#XV(gU@=JkVC(e5zcPiZZXrDXp2s)P;-(LGi zKQ@WVXlR&mr#-mfk+h*GPZ!V2>mMt1>>(p_$hM;qc^iFu!(f~txZkYr z*Jgdem{c|lbpm}0(Qbr4;TS=WH!dENNA=YBrzv@q&O*);vUxQADK$@**LW{B$$W6R z$_F3%)d2XQ9N|2;F8RWl#w3!#BpHBH-9Oxa!-I{ouv9m?ZFVD$wXa6e@E#w zVY?>&L`yVMXTzPb9h6=v`;=zAjrbJj)lfW*IR9!l=@0%SR~DBq$aWm&`s$3&sBeQR z8=a_w9hc25cG}*JZNCg{#a|Jg@Pdnt z9iq1<2uIu2Ee&YP476pxhF=Hjqv%1kmpH#^E^tYkUXH4OFH1H41uw55st_>ej9g*xUzlcqG1#*28XMLId3t;0kpj+G29*s?$h%^}R zYr)x&6pqS1*_%>2{$0ycD*NO=67)W_FO(K(Z_A7&Cua3~8g|TXytWgYI23f=bWmGO z?b=41N%;%#rg0qU#(i_)WeUQW~?MOL`wtdPbRvWup8c ztc7o)N(YB91_4bN?+t|0`FtBuE;jvp5Og@3H52EL4KkgLe@Tmv(dArZ3h#@TG50Jv z3+MBOvx9l{*+#^M{Z|3rZ^AhLH;OYNiGNEBX9W6!d0{-$dA}zi(=O;DA9Ob82n*nx z;4t+qpvQTp6Ptbg_x@;Yv6F*xBj<~4fbC%czL}COoqJ}R8$ZexKI3zV(w2>xg7v|`hjZvK;g5v z{I-KX+2WDSsTcnNa2n@-A9u3TqxKcN|HrRUYA%9iS==uOMdkD9WUktB?2>Oy4^0yR zr4{Tm}Lq#>btKeH-yI?*n?l+Z$%BB@eFSxBF zR6-rX^pc`GrWfOEG7nx{GNWkv&4uxJ?wA(3`HtIX5Zzs*v}scdzC`>&B?Z%q@3`l7 za?>@f0H?j-PU)F5|H1MaBz<~l#x&7~B07)%^@@6W$(?0W3ud6kOs|@~NPVeqSYXYm zuU}L}xuG+(zA~czAC#^ZEJ9Y{D}H@F9R_!E@mPvWnT^m`8Rw|gLp#a&tCVVt zwUE_S<&{+n6@ORnFb7lmA5((k04nJ`16y?bvY_^`iJ7MolG`DCQTJY(#zce=2b#Cr(E|V#iFantwkIs_;B_aTL1H z!?l#`I2}D-Z_!8BYjDBjqQd z%B@*7<@4uST|trW(ENq0J?YDQ^lwRo4PspUEj-J&c~tkf{bEUz?-n-qG>8U~s%s+s z7Pz*dMNPg^p`q4F>JmQM5RGj<-*^4Rh2KtF+oPzdPxD1ZPp3cA``KP=dKNyHx-P}H z01H~WAKG@;ImrC(Bw%ad?;ZTnHI;r?7TAl5d8%v6gpP==&Gf^zsOp@zlBa#QBObK| z26mZ2c*~lCoiq_&&}W}n`23*tmli&q@l5}srh&}^p6$2hlEQEIU3+oibA8rbR0ccI z?s5-Duv(5U47VmzvpEHku?=V`yw)(CvI{D3&%`UD8KN zEU>SEt>{>ffhG?U;m;?*f0zW{kp%x`68z01cxMv)WD?wu0-Z?yK1pyZ2|hLnUYrD< zo&*mk!51gNA5Vfmn*{%U68z^$@Hdm-A11*+PJ*ZS66-kwIDKnx;rb%>j5K~ulrMQn z@SBt1cPGK`15RgP$+cP>3mfWd-7op%D&u39$|@Ha>e)Sf2Z!~@nOF+dj(1Ye3ma<7 zs2_LF0a6eLak*5Ik*ph%`I2`YnFOFe3<^^{odIHaC!rOWlRpHxT;f@>EwxCe7729*!b z*UoREr}E0m*{-N?mAL~(tOBGVEgMWT)qIxSAxH2U@gSRdtK3qDO}Qewn!vJ*`FP>N zsaR!YbHF1nudKcv16@ui-W>3gDH zPW1YVZjDB-5{GUFtmE>H zp7>MWEtjl6qjVAdIQ9^`VOn3QNZfDfowsd*w{$@dU}KuXm6=n<-u$AI^Z&pHPyqXl=*}_d<3ud(C>4jjh}ra@d{q+p+Cm_7kl^%zLIg0(_-Fq zle3Jx<$pWVd&|RXo_H|`R+p^j6gdT#vyUj=ESFUM%GpPvXPfy%J@N~FEQ$QGsLU&W z8ZS2U%0HTMk|$e}N9<|6e2SCssbpN_U(NE@FfMu!yg`fC(&BCL@M&j0V(%_|1mBi~ zkJ!PBJja+%yGI_u_axzSP{W65a(>9T@E^(bT=tq4IR!td@foi1N#|D);Zw?dG8h*= zf)8Sx@=ND4+Qa7*$027g3m?I!dg!HHo92mEa5-bj8}DYO_m-=Dj1&C`ExoeefTVX1 zr}qYWx5p)N3XXk{)kS=+aGmP6R>QB<@MaAkso~o+{3;EX_fFz3bF$d?* z%(%!YxENUoJzkO372sD&p%;84<3hiU>Bo8K1)s<`$*H%`r5--hxSUV(@DV(u@v&SH z)$hF?J_p$^?BOH0oRJ{%&*XS(J@kUxN#b3t#jE$fYZ&*It1TKmjUTEx-WM1bJqx~# zanf6smfk%cK0((1uRMGNf5SsRjp+}1=mn2@=yRF=u!ml7+22C+*_Y{Me+x;M;2FK# z#8A2{EnVXn7e1$0Ke>zxAHn5}GH+MD)`~^>E+?($ij0>MI^BLsfBlu_! zy~sJvLofIZ9{M$$UsxZcE|F94V#dAsey@gK?FLo9wTz4WeVPAa#)ZG&OEo@vdD!OR zBWI`X^zae9UE^bE^6c^OS;PI^J`W$k4=3Ss%)>|e$5S3Yf)7e}g&@7@{bp_we42)j z*5t2dT=aR2<*#8}^eK3)#z)uZQV$=S`K<8p5q!1AM<3_Bpy9fn_j&klVg3g_`~}y~ z`qTAu%)@6N^Eu_=BeEn81T+R%n{L<4UX9fzNcFvoL9zKFE z)#Mq&v~*jo;pzh@`)y}j`1j@az@3bXoPz&K<17nmpbO|o;E_UHKF7ZaaIHxOs^wTALL=WRU zxah6HgNyv@Jh*%}_#5n}|DQO!tdh&8tG#n=xv1<@Q40zI->31U+!`!wql=np9DINvQCzmzNS5c%bq+TKLzKf;aj zK_;a1)0C5hm-OEVjN;eZSUeiJTmgQ-^_VcaB)sV1Helo)N1odChYa_@(lByLIJw`g zVLEBb0R5@UE#U;23kP9d{iSjEs3(BPFX3mykw|~-tPov)G<28nqQ69O6YnGZ(c%>A zkGe~Oyy59}(pz=_8BuQ3Yds0`Bq!E^vhkB9jknZw;kJOM zQo95QDyM7DP3v}%KR9#9wd+0#cjuDei*z1?Z{KpPVaGaK^{3YO)^+$dd>QBSz*fe! z`G!B%y_#x&8L(~M4I40ESbJ@>eS&q6?O40J(KIIdjbPg{*a|g*|A>HbC!N`lGIa#( z1dNQzCxSb1=F7Dku>@k7k#e*V_C!(akpq4iwAS_zga2F%b+ic`w;X%aaZhHKA7atWk|;vQXeDj zv^M?BlApMH0AbzkCkO}owq98qi8+zr!(LW5q`y^ zUu|jxoeyX0{M@pq52zl#vjj9`t0nrH2b;kd!XS^QThL9%hTy|iZ=7?Kq3qfoAp3rt zC-Q)43>|OvwFi?NHqkw1MuvlKLVEvIe&Y+{iN3t^zQy@Q;DIpc^e`log?ynfDz>#2y0RUV^}Q74%n}#Fn&VNVkKNFBl+#7J|E#?T zxM}USXORV^NShLd+bDAPA(%@05EQ%a;ec--KU}Bj=g#;U0?np6yTIKGpT;be^YYO(n{LUT+*I ze7k^sdlwye<88$)@ef7u-?=7=+TE_6Lp{WQ{=eJ@A*N zaiq5RCa7cyV*lEUum{jj)tH9%Ww_Ly5IKdh8jWLUTygS5u#Ie#$Y$!#81G|&J4t6v`TFB*O4yg%E&H2$WvuGF(zSg$*(YOF6mfQ52^%Mbhc#JS^n}sop6}<{ z5e2cg;;tzLu!ApXB|Gt5Q%uO{?jvw!$ny~3}c^I(S zA{(Fh7^I>IXF9rJDNSVWCFfqI!bUxIjnVe=(*S*`i6S4=-X7g}?RNKb0*y)IcKG=)R?DZo0bmC;d{FTt zuw72D|Hr?ocqsk9K-yzSdk4}!g3_JVJ>3EDI}9CB`iXy!HAPMgWBfy_A6rZMu*_3G zF2`OSohV0?M%ovm9CUj6Nmu$a+0D^ALJIZ+ps_S;_ok=dtUM~47^|!I1vA$@hZN`7 zp?vzbHo_h(3v{H9%HIcJJ3er0)%C8;qZ&se|4AMile_OaZh4S$fV1vKx#Q8-l+HHb zoLY+aedv|^gifcaz!_=88*#42UnC1>x@D_(EOS)>ziYWP17U+dV5{qAGz+go{B99@ zZ1``E_^rs9C5B43@dbObnPpG*jj$*Cud*ix#@LfnuC*tpPO>NW$g?LCt?#0XTLT07 zw!XJ2;QaAh0VfPweIN9-+!%M=nI*wi@Kk#p(7C3EUL6)WjOUJvvCjl_Nbfn(6uaNy zraHxL-yo9EU_oQx6Gb=rD;zl`s|C$*5Lzut?ylKI)BVGoob}f7sY-V zu$@)uD@s#oJM8btc9xR9)Yg;3e33)20Y2nM8_=UKr*BHDY1v5MP1qv>d@}<`V~R@S z0HiV88N@ye1Gct9r&RtPN)1LjI;ZBDzCk&Z|2trd7)1K*U*;g)u&IR(NEdGUC#m#H z9;>{7T-2_RJuK-a3SJoDj*oVxqkIP)*+=8dk{_u27u!$+_0KKyXkSpq)%)I_EWC5A zMB5hFYGD5#;)k}jjq;S*0mzK<+8^z>yT{6zB?sbdz(BMC;Xd~CcgGrauMIAK^z3GXd%j1@ub&oXqOjl2yHn~|3p zFzec}Ur`u+VSAc&9hH}dvI`sxSu%`b>6yi~@CmS`;a z;XKTLH)hzD^b3??;j-lKf8VSA@J`6?+*WvQIenM(4T?5FX{J* zU|SG6qq=9t48r!evVf=>bT&h2H z)w_mq^nJ{o-2|Fm$a6Cg%)`JoQh@z*%HJz>vd})4znA6|;+|=w9$ijzHV8W`Be;0k z#F2G2=E5+Kmq+JwFPn%xbx`(;5ccGGWZw+Gn?Q3E_kjPhRU06~zo9%D;FAd+m=F&I z;ZJdHz?|dF@WUKi-j|F)d%uk|FTp-TA%yj&4I``_w*!~_BHb0BjFEnufIp1=whO?M zbU|fCl})6P+@hlj_*Wpkk3pvu(BWgyA<>0DiS20nQ*3(&_)vRI@{!)*H=gwTCUCfo zQI>IoW!z{PODyB7@(X+htOYDOr)<$eWxh(Zbiug!!9@5yFubmUX{ww`T0a-2lCxoR ztqh8-hpMaQD--JaMYUwjTUChyLKoS0B8s?awrl@D_M4TkzMeDRottp!H2ZG09r&yn zvaWd)-M;b$#4GPmY8_QUpJ~tcTHmwq*}xiqaZ_4zkHV)@pGlbuW4^9~CU5V0pt+fu zBs?y8r=pIpMj=o>-PxA$)~0|uU6Kx$ECNGyKxeTyiWD#sV11ADmh(;>8GGiOTWVBH~ZFq$2S93mz36$ z=8e9lO}?)n1OY}d$e!RZL+D=6r#(>keChg|?rAP*nlkm7qNj^XpDiqY`xZAw#RViy zQ<_VjE`FxySw%bLZPN1_%;#5dgU>eK^H;1NQTTNBGg(DV!<&aqgC4{PQ<;#y#de(* z$Ys3`l>vku_k8O56xf^I%<5I|;$kbY&!ssZf67~lYnnJIFBkKRc{9BrciT6fwu~>N zE#nJm%lO-{i~Q5Q3VRpRZP8nAP7zC5lDVi)Ep0VVAt(URKi_BlMG)3CY*p!UX=pck zFI{P`x85x1Jw^TA`qrCsh-S)LZ_cE9$y;wy>XKfh;{VRM*q$n8&PYv)bhycWR4!TP zNY9DvK2;-z2H1Pi;L6l+{*0%{63z9xe6$Zt8bg1)mUn?Jeb2bvQI`+N>84J{$eqXz z^=jbMo_H^6s1xDnhtyoJ=p~H_Q#UBAI!B0e3!DZRA;qQcr3P9Mde zi2h^XM8BGgifTK6C9_*i1HVLk1_D=e?Oaq;I|4peGA?!t`+(7P9pkk$frm@A2e{vy zg#WZ8IOg)_SI%~)^3~=iu1O@FAprBh*$W!5&jJn($eTF9oxV?KHpr9w3(<#{RhQS7 z;WY3DY-3VYS*G?%QRaFsU*#mr%d*;<@;UPj3X4qO>D1I7kywSf&?+_)5LreV2}J~xbduBe%VEiB4h z5y;fD8t2wl&6~FXHi;`$uDIV2^!$E7!)cyVu4C+=Zw@*x_O^uUZOsup(?vLax0mY; zu1ADlCLrCp{Cn|I#`}Ywi;@a8m2q0vrQ>0Z54DAIH6+1Db3LMXhX^t5vQCU}88eZ$ zZr|07p6i#FzCpuvJ2$bLB6^D$^Yx)duj_3h*E^!m5@OtQ87KYVy&!%C87KYdxSVH4 zd~|y}e0NtD;hAwR7;|X2p1-FxT$eMKGs7$A4UCJNqSIo=MNYxRKF2HPAa3{x*UOLC z&v@~MB=l>N;G?+<6FI9{7vmTgIR)44QgnUl_9UeL)yyaC;Ujn@jI@ez8C4COZZ6ty4r(FKYGxEOMjWc@d%$Vm-}1~F8$w94=(-R=l`ba zp3h>8{oi>`OF;h+4n1>qQaY!fWZzgzGhC8s-0l(^QoV$i`cGw!aBjBYaxbxmkY~Ab z_Q_+?b%hri{#tM%o}8U=zNMUQy)7h9kzWXD982MO8JxgIn8SZBj<^m9FX<=+Om3;a zLY|uLx-0?sF5%>UCvb7=q*riw9V54wb~a<)^pBMIJsBhN3*T}$D2syv@O=$uu*DIQ zI;e@0@RI-J?TwpQ$a?E796yQE7k}RH#M2`p5PT!_GX}Zq0<6O;Xutfqcg+m88n>At)WJ}Gt*_3$)eNo7gL|Y| z*K)HNx;Y2#7x2BJ*bKe@6}T;5UHFT@$HP4i^m%6JAF-!%{!Cw8@H#W}Zdi*zrLSxBy>$Aa6YO4N^6)`B!)7^lJqP}gQ`gzEgU(B&50sxm=pze%QkLx( z@vSJ$s4K_R=Z3p+CdP|K+j7v`-z#wnW(FO|bF}4YGgNRdVN=v|wAl<5r3KrB59ZVF zEK0+9oG1euW*biZ*UarG6K(B9-&&PxlG8j3w4TQqqvA4VU6EQaZJe92tOkXIiKKXmgSCm)3NAiwRS?sH4F8ERp7 zG|LRNb2+lD#H}0cTwmI+GDD?xW+=$dS>Hgsg~KBKeQr7E z`fmH$7Njwwon?%o3|HeX%+DPw5pH>Qr2cFyhuWRDc28KfY^ZVVn=d}S_D`s{L6PSH zGxX|w429v=r~UJPRPB!O zvJrZ}1Y!T^KHEP*okd&I{);D-fA|(NlomwX+ui5(QnX8`^I?9r&>rn6G(*NwH+;tu zBQ&F0)617lrylXOzwgS>@*j|!-8RBn?6!(rJye6X9K795q5|D0>z^TOZ&%8oR^qqZ|p{5jQM-E3^LUh7G@mb`AQo&M>cU;u*XQZWpa5 z+%q(6e%^?F?WGDWjayCUdhm;K98t8z)%dfsheuvI8q1jrzjhAWM0F0b*Zb_jV}RQn z=f;PS*4dPPc5>KZMTNZTtW->|h-Fqx?D!+Weh3BQF8F-gnU zp<4@X!>qHuW`vF)AM%d@Uv7kkHNt%o=L^h%zVFf6_f${&o;oJ)x5Rsozs~qq@Wy#X z`F5br`YCw#giM{TE?Rz!{tA6$l%LywgtCq{CU}T-w*z6(|3>9`B+50nFXayyAzH)o zY-%tP{Q&DurVYBzUY-?cGEU{_ZN^6K^RXsjls&%Kp>-*CVNd5pk}m^k91fihG3(mV zHs<$*&XFIao2{frj<<0((tC%N$A2=MP4I6Kxl#U0QQmES-W7&BJ1a8dU@T`J#j`I^ z7ySxoNSAv8b>WppXwTztuME_6lo_D|cWb&Fs_Syd1bgV1JUSO3{|4}|p)af%$PWkV z>`PJ4(YNPM4b-&^fb28j-yio<=((R;cORy38U8x^5#%HEn!gR>kNb?!NYtf#+gI1} zFOUOcvi!w9mG0_OMyUQ4O&00rv7W^;2CII)l6ZcIINDGLIKAOc@Hi5vGdf(|eT8V& zU@Y)^;4dJ~-{HOjacp<}XORCfJiiFJDE>Df%QoB(Vhr`qxbJ}<$}Z(YDbcR**R`*P z{z&eSzb^VD(m>%#{dHlq4f)eh&QPZFZ}8Uzzu|_vp27tX4!X`ygAP!x^G||5$~5sE zPyYA9|1l%<*mC$)`|Ebyf%F$?=^v=)Mdk#1;F!GO6mGM>PRY{ZuiG>gVV{6ZNZYHA z!rkohc`1nTj1Om#C?=_d!B--tG-VOX^$UtM#E&jT4++UiUEFG7rbezB%k^JE( zGv7y;(Sf>+SE2vB!7bxie{?%xce#iYB`pC3V=;z*XpYcW%Ij~kCTkS@()8tR4)RkZ)m^r_dxdd zUAZ1WJk}4~cv_Aap)F{;qRe;K4d9!7Riyq*tXo_AN9y-{UsJNRe1x_t9bp3Qa}fOB zN84|uy3gSc(5I*2IgR}h$G;&CtEc;n#Rs7~KTM$dI4a}1o<(+D0EXX7I&ZG;a3FQbQ>rp5`-+wNhJrhkg% z+(PlExVVkBE6VOD#-%}a(-@oN>H*poze{V;*c0W{;O8jX`ie`9P>`R?QKxL*m67_* zv7BoWE^4^pT1Fy20?@DI58BOY=qYNt{?TXfjK6k%?m&BBZyFkzunFUE@Ub`_F?SL= zkg3&?$5WhlPorEjUkmwo=pu}@_<7?9@L4`A^6`dP&PBwBXE8#2|Xvp(UvjP+mbAERF6qFkN8Jsot%T;7`~+!23W6Y^TdkIxep z0_~r$?yML3;u@5pp%~u{(8?nEgsyjIltq-?Z&A1{SZh{vELmUK)>XVfVUj13ICwl_cvn=mC7w!0+RW-LlY#I+lq!0sF~Y+d45XP+)vvLL=%~ zW3S6{@YQj=s)tYZZVOS|Z@D~!0W%cl{vhf@xqrjOtykT+ZU!yIc@yrW=Mugb5sv2q z_Rq)N#GH~{*mXwL28{94xNz~1e$fxo^BzXo)5nD`BaHq`>l^jwbPs)_=efZ1+~MJe zvm3kd`@VTe6QvEe7@K4{Q=zVM@rf9&8tQ#v<^|JZUJ&z$Qxnj)pdYu6$9_!jx)TsjO|>hJ zePTdf5cE{{n<)NAi{tb38y*cfc}aM6#5U~5*!JkkKgG}o8O=)eg@K31B%vq!gR4K{ zID47Sump7Ru|~IXFUHy!_gU$p|yU zz4Nvu;1SQuZvE^RR6o1FL|4goj;JaOV zSeAeX#bLi4bH6J*Vmc2dph=ugyys#(@jw##a?D*@w8s7|W1_t&6Lv{rkK@kkCT$yN zULz1Z;eInf9GKU*Gf5muH{Iqz(3XI{BmsR~m-nSOli_c74v#cVjpZyPw{Jvb0^AG8 zy?c1%z^$>I8gg&4BK2_3Q8d|+{&3HRyK(TmJiGIXNY>)P{Tc_4$(wOYEGG;+X_~s_ zH^yPe?;#23Nk(fg=f&(4r+*R}aOS2TkX#BsAgO zOfxIR`E>%Cc)Z2LKS<(lk2M|pr}&=3^En3DSzz3b z^Bz&gvLgNS@E%O=-Ia$`9M67Y$qqg(%gbfACuRswpZzc$v*deeD42~Bt>)2ua} zuaXSeR-|cSEaydX@5cKZ-2bfHBO(VT#ByFp!iV~}-aq2@`5C|S0EKyKiWA-u+mWdJ z8)nOX`sVf_${@YZU^ln@-&F3t#|<0ba$D@RsvfWPJNG1rGp>(r??cEZ==IhF^znR} zp5nj~_nbNz_y2N=^F@-~cSU5z=vYo|0@`@o-Nq}(3-oQH6VR)?$T1zv6>YZ{)~o)* zpfa!!%O8@^tF(6-&LEOyR#xQWD`Ppg!L83(TV~%Jlipiy)ZSZel=qe|sP`6o(`U?S z=kT01!ksylSTDhU;xe+_bWVcCUY;4L9~R5GDuL{A-E_+r=mz=nha~(nPxm-Jax<5m zU;3T@NFiHJqx5!Tiu23!`Cp&n>`vexm%UpXg}w%D)Q=L-Q@)1R$9{~3 zH8|T8-2F{rW!}xmw*S!q`przv0j$f1bjqq?I~{j^p0aR3|8@8m4Ke& z4L7aXZvtzk?|<7dh*3-fCET zNZ#_JXG1pf->nnqCz1DeCkYo`$U1!7bZ$#Rqtfz$;glrsU%q^Jq;b~p2<3;a<5Pb= zx2!ME1}*B1m-Zvj+J%{s10S5tNtQk(!!tf-cmf${%~Jn47#q+#E5=bY|J*+3)Q?T- z+wtBiYwb4l!TKML)t8Of53_6hER31ktz@;+{(&dJVc$mR<7qFF#DPCc)MG!Hk>t_g%o#o=6TmkEXVpayl?J*3}Zo>FRI8WIRIVJ zK98-l5MPMD@zccX?lwNaJ37V(6O!;(`n%C|u0EgteVG5FxC`<96JxRVBz~^ECz28PY8Y;|{k&jZn z@9^l$|D@W$tjJ5d&*o7266saxr(0OmFNA$JL0cQo-){8KKj;r!Fg@nbK>v#*^t8tZ z)m?vp-bH;!NxrO>RIIcwizYwc&IIE~l$Xrpz-8=gsZwkP4G($;PKfH4ln z4_nSh-)(*n^cbtI1HHWo>lb&P&G}7&uvCuQujjHcKgC&{fF`cHZe*)`Dj(tl{rv^0ka`Z1Rp3T`v?pebl{o!7p zBrNrJw@&0TyvcO#Jr7;)2~78-=}b>Tr}AO8>D)qbcYa3w9*VNuEe}wZkq2K)!rQo} zt4@wjLZjkGn>8wlKc#o?=&tlyN$8~Ss=k_O|6(`;lF$;*t4DR|rgs85DieCYvSnnF zer3Mt{PpCy^;fl@S91EFGMy7iXjJ-N^f@1#&;JV3={%qRbkq6m`TUosIQtX$$IE@U zdWbd#_3-s1^xg9xw8;P9s4H_?Q07%yQ0{-6AS~&_9*;3qU2I2uPKWlX!JN+blh7-E z*PG6F68Mws1p~Q%^_kAv1T+*UwfTDnb6yvIA#ZguI(!>ic^T6^kka-z=;-~zfL)5W zZKm%9cHxzmV z_e^K1;y*M}|K!=6#w4`ueYqSzV>-bkG>YF^pObq&|65FF-1+~YhpF#zq!)~x>TKwwzMnn#k_2Jny7;}}^i=*>|ARZFCk1yI)7w}} zVdB|3wdASg*^lI5*M}E}oi09*Z!A4w_HA5ir`S);GKNmbGK_B+2)jJ{`aIZrWh`5Y z^(m>?Cn;cDl0CeAE%u}yH7nL5hxj*QJn`Yj%yZKP@Z8kJv&El;C+fo6;7Q|Dd)COf z9)5}M`SEu|s&{xt{59yPOukBf7;~E3uOST)+C!>wEb1%fAzuaEx&A}@HDsTcMw^aX^aIzn>LJDIWQ>~^X@^sS3<%EK<+uHDrJglU33Ndw7+F*(s~z&Kpl zkzijkVQkX9b?NxxDWHTT{5`edJXK! zNn>=3*VQ-ON5E6w4dy|gUV7}&HHp3jx1`bgh1+g)d%yVeS+*6U@5ydDk@l??_9moo zQP|jdzb(%)?fq^%{o~)DuY^3Qc!y|2m~g z_Y|Z@zFo`x1*|zCeN$eE&Tn8{(mNC35aBZshG7ESf!@SlG5&n5l%6w7 z_NhG%!&*@X7OADiI9f`={u8Z;b}OLBt#vz6;SFOlnW6!X|7y zRYW^aRcTu)xo4Y_40J7}pRT>Jn$0iKj#utp^+9-vE$Tj(PVMbf*c52?&v@E5jW)4z z_e&Z_(9=HJ`KhSao7kM5S*Sg@wo_PKxmc0bO|}w}&G$o1xapevF3nw|xqW|l)_2?6 z{sL3O{1eP)eK)`DKiCbt8Q@)S`{(MQZ>AQEwgQu_rrf>Q!<5muZ2BqaWBZ=B)@ObN zWV8Vnl8bG(&U;aCOvS|#5&6+rB)a?wt%0emQAz85Q5ieeqS(Oh%iZ^QQsqF=5+C09 zgP-Y!{t(x>cs5Xdk0&ZyawXd1$>l>e;oK|H9#1a)-@nHb$<_DVD2)k8@Tp1gdy?Rl zz-dpSW4P0$>Iv@k_)~i%aaO8&0qimSC6Z@#68u@_6Qo83m#Q1MZ^mCDK2(Pi;jbsb zf13pVV-ozYNpRXzBT>9rN$~MW@cbnBlqC4fB>0>p_#;X1ND}4Iy`1U0De2_9sT?lOMaJQ>)h~YPs~Q&6^7#~SW8Wt{mMyBUT3Gu~rGdSz zie}ssDk>d2@jBWQs-{W~sVHAqUxkA!?w>Qitg@;Bdq&l}J3&>@67UE*sdDymcK?Usz72kL2L02{oP+h)|BCMFJKQEf!g;c0+v836qFE5Cq27S{;HmG` zrKJlxujj--*s_WR^BZVat*ZGI3o7T#zrS7=gz}**o}}3|i|VTpfJP2N*06AXRo$X; zP9sNCUfErEl6Cf+8VOWYUjHx&Oc_VlaP{l%t)-VoYCq|sy?iclo$9xm-Ti_0)9_k$ z(;168z9I?z6G`azX!QNrO}AfZxZ5YXz&^%hk0O3F4zh#f(fLT1?3EvTHmJ)hzr{G| zLDx?%-ftW{Xj_+?y!A|%cQ^jkFg%QZd+HC*TOG7mNA+?ouHel%wu@z-%VE0gF4X!L!V$eUk- z829E^IuDG`p=aDnU&=ViBl}KK^ck!y;zJ^*u}ni4m+~gK#W?ZN_wJgg;p|kLZqRUj zFSk++*Y(-VO84qBjUyvDdHXZPKb>)sQ^)sMZbH2J*~hq7KSq{I@6E55uW)ga#~tIj z&+Uv8J+o9En@76--gsYN+#Bysjb1P3?Hav~AG^xsPw{5CPW3x=R9C#&8XjVt;??nE zj1wQdzNcU91}1!%#^+uQ*UR%_4Ii%24;kIXN2foQ1RpmhF?|{xWQEJCPm6J{KGUyB zOh1HiFa2r8DZRR!gC@9qy!bc`AK{Xy-&_s1G<=PQbCFTL+a|h1Uj92LCB_dkPI|af z5O~zJVe8}N-4%8HT+UHD)l>#ancXPYq4K0;}WmnH)wqH{GF!Z zQWl6+rN+NM^QK!3=67IKR0;rTJWQ5r+bU!(R5qd`n*3+0DUf zk7Lwk5YN9g{Iv*6Jbn1nFNt4olgMA>7g`dN!jBh#@6{|ncaL#j2`}j=g%7#M#VK6J zIu37na0w^(JK-;Go%H1k)Zc6l?@fO@hnM#q;VtsZb2%J|^1t*pmtrv!QvTB%yo8s! zO0s+7rXZzXq+i2WL(Fldvj=2&u`-RaZGaIdp#bZ#PbzYcXzKxI$tXr-(qkkbEG2Ow<@rB)~Q0A zjZ$f6o+=w|9529md~^<0HTGe94`{4`e*!K_TC1*s_M!cKKI@L5fD)k5otLARHTTJ4@s;u+$4MiMMa2~wm!|hNiHN3 zl8^)iu|rVoOT~Ex3MzgFwNpZ!_vbu?DNKFZ_)+VqZ7qIbYuoT)rNz#GVoOw-_y6B} zt$R0{ds}p-&-8hJJ&=3O`Jc7dUVH7Ywa?jm?b4~wUiR$Gedn$UdOcqn^nU)Fpbz## z%Ue?r^jed=H0T~4i5=JtpN^-#ciYYZ_?|Z!GXE$Nth@T^&F@C>ZS1Yj#5>-ZT+;EY z3rjnGT~^kC{&LWvw#p+1V<&C-ZLI&6U&s1wc_-F)%Yj($Ex(EN+VZPd-j=uEV{tdq z_RP(_=U#|C=AOQ}-`q_%N9R6#^T~4;L{55sRc-Gr|FN?2NWs!xTdFI1Zz-MCYs=d~ z@7r$;V$Y8VqR+n_ob-H2q}P`GUctIiLI2waMo(RX``h0RPFYhr@B5dn3?iT(xTd=1 z*~_X;dLnD0hrays@LrKak49o^eh`TweX%uIYgxfG>^?K-_{{`-r#d^@ap1gI2a4UG z0;C~UTXiHEMAk%VM;s}I4tH0NSW_8B4izA8@K$gR^3d!RMm@ua#Fk&bc>m7LFWtFw zM#F@yIclXzS``sV>{WsqIRmawMzhAKB z-A5DOdbj%EBkx9U{^q;nIb~GPF?v{}{fj#2$%9V2ee>*$PCzBXbM)+~I4`4jov zH~hOD?;^f9%8TyLO}~}guaDp1hIa*rYVf^2aW1~!mPXdyg7Q@r4Z26hBgHe}j|B6d z55?h!f_n-j{}7mRg1rxm(HN{l)jP0>>C121$?)6pPX- zyRiqj*}DrH3#}W1bTPjkJ~!TtIiuKDeDIdjW6>A7qR}<+)$tG7;WuIh_QPuV+J<}g zAl5eq37<-z|tz+)(?8N(GLyN zs`J6!co;u*z;wk%(f4TN5c;Ny?>PE7x_oPgmQR+MY-LpahH@WxmRFX`TxFK!b$3s+ z!wa#%=3>w?1Y|!;Ojrz_G_NM_|&zgmpgRoq0jUF z(Oaf`jptXtH0+x^Z`{&n7tfI|-g+9(-@WakQ9M8W<^I?3-1eDdg#6<@1V`zA2u+)AxE4-?)E!Y9;S)8{2I3uxbDI z9_Ib!^M{)Fo7P)?|WY3`L;;|4)fg9em%SDVDOWVp2c&1 z{bVz=m~~^hk!RZz_N~FU`VTYuzii8{D@k|N^Y?#|=l2@N)$;uBxBNpZ&yCezU&`~K zrO&P6IY0V?J9z$}=euipK2SgVQJ#PQNcVSnes}3&qZeLhI~XXAzYu@sm{C@CNjUnN z#+I;X+=Ow3<0fBl(PwIEQs>*-^g9IioBj|4kv;X{Ze809I7HZH(~CcV@q? z&u4C!0ox@$m6L_;MZq5D88Sy681mqmGuIE^a7NO~AkVX%DE42%w{xR!$ineF_f2|< zg5gM*U#n~4g;5I_edF>{{1Klm2A}R9P$9VP`=R<`=xpESO{K~5ZJveJ{Wg!t(nq#$ z?Uv7f{#*O?h=uv>A8ho@x9~js#N;_H(H~}|XQetd+AD34kG8?^&9XK*e$vHuBOZH= zFI$V6n)z{T5k60u$JmkwU+Xfr^Rba#y>q{$sV3Q)8pp40<1RW5=asAFb+jv5x#~7;~E-~uQRT^=7N^iBt939YbI5ywsL-Ra*-|LBETm+g$M`L zoB3QWi@4l`D6;O6@7~}#*ERvz9bya^52n1vxwFV{ z?u(H2H(vnXm5JWL`H5(B9av!wEcUnV7w^__8^$f)=4ZjW92Vkz0`+2?D{sW_(IVAGdyEjeL0NW`Bv_opfUIT?fs8% z-vv3|$9@y5BhDB@dgS4bZJOtuOGs-EeCebah8Kl?3)}#-am=FFOa;i#NOk~zr1{uJLJhT zFc+#%!}|j8p}YagVH?U}Yv1?|>=QSMx>$nvb?&#GwJe&nK=x|*e|QAEs=!P6B)|uC z5A*9e&l_V_?2R4*qr91Xv3qhbd*+a;hfmuIIv-=bVtvZ1vGr*m*VkkJ1?spu zd~#?@aQgL~C`Y#;-JCCuet7Gx1F_!+b4tN~ zuJEtHzUAa!LtTJBb$KHE|I}RSfhZt6+%Z>(du>x`vt#@cK9KidY})!Lb}Gg$!#Idv z$_pHM>@YA#IP$>22Tz%{e!zy4uS*ZK%yz_P8g(*_U3O>xnXi`Nr|+w!{Vu~a>3%c# zQ_8_Ld2YZTk0bn%eRR!S>p6EuuX)w%bZj`94UEmz)byBYG=jXsa5xhD5!uTiI|bnM zWl}Q{q}5I^!RtRl%g5Oc_5pv+u^Ridw2<27hj-o zOrwV>2e=uIKP@x*jOVdA@F~E_XC8@gn6iTN)%eTC2lXc_enSrYcHrcn5TnJE8DQ+| zv+;i_2mVG5{6G%;cfd`$#9&C^o=0z}jQDmB=h&_}Wrubcf^iZj$8(tanVCgd%`MI` zSJX_YBwSh3&{CbOu1&f0?&MKt3MHq8nt*~iY#SRI3>O=f6SYn$m2gT{UEhc~urd*| zAywU4*Vv%5VAH&~g?e-2G8-p0e67WFSqE{Z%i3gS=Cj&+nc+%%k%vE~)V$;OY%w1V zUEKWI@8x2a86+V^m19cNKndLtDHp`eOF_Zid4U=iA3fpFyJOa89Ne9k@S=kc65c$$ z;^3}42L)$(&v59E2+s7n_%NZ-v8D!zd$`uGjUKM`VwZ={lk%zWW|Y5{+mAnH{XaHL zH7N=43snW?MXW*WPh75tXu*eJ2isp>YWN`papW4S>bn3-mH8ER zX@Kn|c}g~<@e>Wtu_k#IrbF5b4Ig^A#;@l~@LaE5(xsl>^qEh4m4ugKt7L(OAMFKD z{VCyPxL{Oq1>~%It}c~(>Yu|`4X^qqdp~XlX_t2eae2t$694@0xyFhZ*O+67C%<=V z=6?Hm$AD`Y84mNI!(N(SKm3K`FDm>vW5w~4CyoEOW5rHq+#fem=vXmh%cIT0K6=5H z4Nkq#|TjST6g?u#+^~~ z-L^Z9unE|={LU1)Ip{zexRu}S5N6OGeD^EK!@gzU9nX{a%vdx#|IGIB2N8^;e55chlX9hGU+^pP*e zD9X?1gT7}S9c05`v+w+EmN8TUd(2TL%8Gp%ccLx~YUv&C<~PunA!ibL*D=vy$_V+k z0VlQ=-{3G#+2ZFxHjMHO0)Ks`>0y4MOlP#%uV2@UgwJH`Z* zi{D-JP@A3i*~SXz8N&bkSYZtKXxT6<O`>|A`3C!;-@Lfv9rcM#6C7-nryafk>vlwLZ>G$IXP|LgxH%WVEc~$IJR%`c>R)c;@?T; zIYP%xLgGj_H1Q|qplF)?GueIoK0SMZ%I)VsGQf*GoBxBLWluLLKEAkNZrW>@klDB)nfP<9qf`x*)DKem&FH(QB79;odmcJ}vLFl@<-ZS;Df4@$W?Iw6^6^HHFLZvYv`3zV1kT ziU>L_9nxO-@?$&;XY`pvYb+6aZGUxs_W1D=i!5^Db$Xy<(8i4zao8yX%(qX>zutm2 z)r>v)-IHT0d@tG=^lIB#b^jH`r9*<#s_s9z_!f)@IS%ExFZmTCi>f_Q$IkGV`Va zdWXVB9cKF4>=igU0x$t@TslkSn)s-mg5Crx5haCOa)D{jJK z=F@^9B{w~X@5Jzlv}F&zi*jx?$^rb7W&AB=^2MfudC2ETv+*%ifV^SaeYz0yx-;W_ z`|U9Et|Gc+J@Ss>u$I8gr=@GU+s?P9Pcgg44E2`CZ<})@3vNAtt|=F0@x;;=O`NT^Gi?w;@l52WK5XXIc@) zf)}>m67AUW=>Wb)u`WdFeLL!0XD?gtSrx$j-D;Z{+*GfYaZZ-v7V2XS&*Z=XH>lVMx#L zq<;kGqszb3u>yW3S*DnW&msTuE)23@UW3v9_l^FUuUr>!7;O*tFL@7ZY<`cr8%GVq5R@^(2-#?z7E$*w)wLi5~bt91t%aj<(=^v{Nev2Zy!|erV{ckzmsBt-)fh zTj>1S)E%7n!RIK?i}`%p(VmGRWkT6dzPrGe<+lpD=^7bXR~5bG-X6^9=(#UgMtMq^ zNAisK{DY6x#lgUbhPr&17i_0`o*wvCx`> zD8pS?uR&S0ZD+Y-+eEDGr|etX=2SvP%o+Kh4Q+k|`MDcqntQyTj&!rVVf{^_T;Tn} zAnJSs^fD387;Z22BB%sy4f?hMwEdOu1dAu+V_g>R+u4?UI$ksd*eKj{F3-cz-ENdc z#*e(4(}}!qi=s?`rfu+sdsPHUD*U@t!-i4#=eHZ#;d)US~WS@afQI_@&$9g!tw`ae_ zaw&b9X*bb-o4%N3z6*5Z%eH1c+hgdzK-$c78)x3x+qOL$zjvfw9$miUm^v9C9j)LO zTNTH9|DZd9c~GMe7wW~<1luCaYub%=X>S?Qigtl|H|gr>)zLFK=w6LesXQLuWjQVK$h06->fNaqZWE zGaqdlto^_|WE^)Q?Fq=b8)c7nBHL7xM<(q*FzqViuZBO(D#{Li_%rn?7TkJoHlFNv z;jcB_AMZUq*1`BF3(C~uc7#{CzCN(+-o2-nb+D~unr=hh`DtPtr3jW+HjS}e-E8~q0P(oWfpzJYBDb^j=zLq2^@ z`;hXIhR@$Z-YQ?^8ULVX(ta;K6k_ye-%ghojt8pH|FZs8Vs7DwExkG}JyNoxr!461 z91~P%8=M@9xC(=9-3#+Nmfe2)&YQM;b!Tz;mUr*%yX9TB%lF*={JZ~(Keo$kqwlHv z&AUI%fBRjw7yB@;a_@U6Yba;CW5dR6>S%|zjJ*ar7H};dp zdF$6s-!U;3OspJ&`?Ij`Io2s+9qVFz6tAem9K*`d!Qv9w9uM8#YjFwaH^HV+-e|MG z#_K%OrbWll_F$ZB`-Y>OaXiuq+lulTTVUZ-^#6m??dXRs(_mNqn<;-7LoJTVU zVLsc4*ww?ak9`u~{0fE#TW1bO{QsE0c-7F7o4T-v^&ZRxWxRv?uy4)SgD!84@0d8o zV*hHigAe^CwwN-aO@Z#qI>@IRvQcK2$1!1H3xor(PdsF-><>QBjmr5PWOCEoexzrj zmSdK&g7;ugpiEST2nX9j!;OZHnT{P;I~a!z$-Hvo&zc6zQQd^Osf;hkFYQhY4Yobh z99tY80vWzCV+U;u?xUU75!(EZr6bzj-5D8cF_-pH#AVxnGfZ2%3g!9Ma?A%!M3y~N z8(GG74)cABAL<`t+p(duyT^=6OQgNwdd5KqdnQumZ&ME_YYCL8Ut^5Gvepiro^%j> zHp<%WcYD&ZQ|{kkKjZ?`UGi0ZG?EAMqaEQlL${TX8UCk_2{#z+ydN%!aH{)Nx0l=$ zM_E^$)u9dO+EZSf7>Kbh#^o!nk1S)Fbu6Z3zUy6^wxpzO6?igT)c4+zQMAFRcNh;* z-nK(Mle*Sm{Cp~GbI4opA2#1^aO7zJQM`LK%3%TdC4%Az`$Bw!j$r;U=(j}@SU)~A zm`GXn!d@wbF08#_>v!VcMc2}=!L~hf6ZU3Go)k_VG%VObxu{3VPkm6It}cgx{ySge znEPzgUSMwYp}K*v6)@heIvwkZhXsdz4Lv2x;zy=n9I_J6LdcqkBEQ*&>_?hV?mE$i z?1uhU#)8SoXjyT|S*Z8O7xaUsj8lfeD2slcd<1)kd6C3EyY2AN-gZ)WG5H3+vTKJ+ z-s;&(eI)T7r=Xwx=KU$IwcXbd^;DD$ zj2BO73l^`$HS;++AXXe3g?($FSEe-r{9W*3S}5lYS@iV3@LcU>wiA@|pMX7zyxTW{ zb0qRi{=J31VITUe>5w-DTaNMZ-3EDorS_bnw_tlP|M#6ay@PQ-1T1{Br-E(mlZSh@ zZ9-X|f_AX;jh>0rjmng*KK(tO*C4&sW4=14?3BmEaxCRJ@}pKp!099nEO)3y_{_*tFHZ>)HA{EmYM7v;~_l^}`i|5f{@g3AH)59|8*Ml!0EoWm)u)Gi6F~wpB@`AJ1z&@^s z)-Er~CeL$d$M=}}e)g7qr}Q?q4<;-(?>l9BM;F?X-80aJ#3Bb);yPJXvJ7uo$0VvE z%c_I3UtnI99qifqeaJ;ShIO0cDZg&F{n*y+mB>TdZFP{b=hi63hmnq>Wwf8MjvM(M z>@UMwf>_7<7{^V4Js-lZuR^=xjuT5m+lFEcH3shrCJjR0-FiLjR-{?`D)-us3GDcc z&w0;sQ-wNu1IkDO{HucSVwNxHb;tLjL2+J)dGL5YQUabav|o9J!7}uJJJ6PN?}?6{ zoWQ%1cG&UcH}+`H-IOJPaTnW6V!!;rVx6#8+c6ev!&sj21VMa9`zZ`JXw1>&B^c|L zV%${L0bQ8!?yX0AwkDs#-lNrd9o-9ib(EYOZ0&|Uv}dnEMDAsMlgwG4q*%*hEp4s?}3h-6>R+wb(ea9 zy+5h*+_}Z^lY)s!*jOx!$jd|ToElVgLdH&vLB9=MQ6E@S(~SYLd9T@qcPW&Kw(17F z(|RZx9LmEOw*+HcymXoKB<%Wm{jJ^l7Wxm`$zMb}O8fO~wE47)F}`2SGDtaD264ta zsi9kffwy2!hCurM%$S1drvAD>!?6|b^&ODCKHK0EF}6vdtVB$^Iu&^{t>Z(qO)Sf| zqU@_~&O{kvoT?k@`kSn?#=bnA_T_2ZGhXe>zr!=?=U;LDeRYQKQrr&#PCZkvT-#Fp zcV#=4-*WQ0exJg$q5Ya@({g+o-8jF9I5fWh z>Bw^pu62y?Hhidj1NS<1;5dbAX_)?7;K!r@X=fQ_K86_gscc5aAHs$ZSxHaY#2@mz zlfALGTHlkpTfm3!tQnTJ=BAU-_MmKD1sqtq{C)_XcK)_!o2IE10<++(2&^_}`-9Rk4| zrl|*fT)igQrUR$Wve7>Se7L-~(f8u~Mxx(qHh0_i7@d3%A#EFNKelbepkrrDZr`)m z@^8jh$CUr~5tpvT<5-dT7Q8bZ?Vo*@$MGe6F?G-TalCu~gy3ibK5beRCvrdn9|I^7q#o5s19<+PQG2Z0(^$gr^ z!~9V6A3Hgp@nX~+rn}??^a%^AibmG96b*+R&;~o8EjDP)!+8I_p*Q!}2#TZN*@Eky z=;;SmqW_!{iypxE(9o3zXT6Y&owX)lK7ejR^sE>7&S?Yuwg6lEQ1r|L5y;$yaRb}l z>s|=DultYQ=G{)k5AYrs@6rOuqV^ldZu=+1j~-oa*9(@yc8KCV4aNoJU-m@iwwpY?|IK7g7J|;|K!txDw|BIRCOo0E7Pb z{h+PIL0KZfR5Yk#%sti+T{E+Sm*=zyAg7XRD$2uiTJYZjavxmT7%psRys;rnE@`dB zih9n&!_t;;QL4H&*-+QAs3mM!($v)0+?uK>K+u!>jyt(8&RDvVtgmfsX?6Jj4X)>u z&8`S5uDayXb6Vo(wEV4m&!yZ!oIg0ixmQ%ozNTV&k-ZJdr_Gwp%WLOM|2%}W|8PHT z-s~%h8_^;BjKTX_ z_?q*a)FOBa2$R*-a2yfVq#Ei{HHMJPaTtBzJh!4`PDRD6xdwFZLpU19XkuJ&O%l|>|eRHSLm+}%foE?>@t zIB%EheLRbNr3_n_4m&e_1(FbdI_ETw>tn*qvZ8Sw&p}Fr5k(Q-TR7N zuVaq7Y^5_GL7W74_uklx)HCnNyZ()7ukXr5b59}A zTP+zd`+>d>o>X>c@4I?UgPgCv#-*(#8~UuzFS|Q$X5Uv{E_uDAUxl1!^Om|93!|S$ zEq_V|Jf2_jz*iy<-WDlczbdlf*2t{BKmUbpS!Bw_bwYo?O|#uki5`)rb5kX=Z&5j7 z&-g~F$lOds6!%N`7j1kQ-Im@Ny(^M1g4+l$SG@%+gRe-qCu}&Q>uFTy)I0OP#84t7 zXDmZsNqTqxjs5QFd+$jMLMGQR zw|@Et_C`um_nQu^^rvr3cd;*Jp{vM()mp5i-z>d|mg$x7K>pe|RhAh_FjX(o$mb1Z z2`Q)IQbVLUE!Gf0zvyRx?@xs6;?up)!&zYla1$R zr5Z!|>$~3g=?uNQFTYF((jt`Im;X5*E4?qj@0z&!*p(Kl5iP6?Izr!l#_^ zGlDW^HJRtYh#wiZd?%|C0Lk8~>#hbbd z{5rwghLSoXC$F=u{a*n3YRYo#65SMnW;1#0SA zgvQ=4T2kLyR|y}6t*J$DZeqa&*rJbn;2Flasa%A27s&-F3vffYx`riiN|NT?=qAoLF4b(9+t3O$Nt}FBH}yVRJP$9&Bwq7NoZfyz8)FjXbPr#AbI~f7+64 zsiz3RxLIYB#jT6$9HxoNZ>X7XAK}i?v2o@?2I(CGt$PnII~cILsr&0>^MB`nrbsjUsNfyDIj^<~po}wGz^|3^Ka8 zQFiXbyE+NnQd75pPEYM7iU{8dn(FjMh}f{uZ~#z)Z4hgOA(F(mb`A87X`UOQGLCVK z7Ey%lL)>K^Aqx1+@%B_S!7~MhWw8?b1@f&B=&Nf*D|IzY2Hw)ORvsI@S!kSjnySe> zXZS@TNL@>1$=tG;Gb=NKLpE-oXo{^#Nz;Pnmbt0cYnr%?;oQ2LG=Zi@wl*glTJT26 zri(AiG6iK(V{@v8OTsb=q0U*k(rPe!Dzbc8q`JNid0Xk^lu?A$H0mj;@bNO0H7>y( zjv|6cI~DI30de;!3|?aLVbXYY6Un z5Fc$X&F{@Qa9vkU{g@ZS66QIFUcV*q(QMddJjnku_R{<|39jiKBF|{I@=*B|Uz&r@ z;|{K6fZ;nm{;G%PJpPL7yD>lC59i=N1a=b-l|M9hK@bYA@+&?{aGyWE?VCgS6bhe9 zJwA$0&B3QlaO(L2;la~(2RARmAtw+`iW@lK(q9xftdIR?sm2EUx^`fTESr=rI^ zp;!IX%7cX9svpIh1ozXs(TR70GROJR9P}SK^b;NWe0d*2IbA%=f#2calN>(xJNU&8 z-tOR&9sHn!Ygypqf$|E1@)SGtg9KN-HOaGKf~(#Xk9+iOLO<1`SNuA`{rswN_^^!V z`=DBfkBhf@^!grZse{{Zq*kDtJw8g`=HM><{en}@OC(J^J?h|}b@0a>{89%m%(pk> z!|$Vd-0a};NzFWZQE=+ttw-+&&hqKvdGgAL{M~kYl!IgbRQf1)@OT=E97t z%fo63b69XK4~idg_>6M+=gF%o%30#z`GS-Gc@92MaKAoY>d>=4-6&zE3a;`fUM@J} zb>(@*9WuJngJK0}1h5szMRb!ww}?h^WZzF5Yg>FP3f@P{L~ zpRTEbE1yoGSAX-$NAU`eexT4_=f$gdB1gPU9-m#pr`6-5_{|QVQlaIk&Euo`TeAIrh#agUGEZ}o8Hzun{WoTTjuk6!U-1o!jtB?ouw%PS6l zx4yh7xL;rPJM^qCog&XWg8Sv+ut%@yI^xkQp5NaxRDCMmUvTBG_#ls7^KpnruQ=wE zn}hl(6WMtx&w(dA{+eGk9)HDaJ$jY1-lJE1X%70EbI|Yd=tD7p_Ivb-_ZO#8Oz%`D zy|oTL&B5Coe7b`l6kPLV7x?iwEV$;2;zt}lGc2k3y<>pAp*-adK1iHlDgTYae~949 zU-4mrlaI@Pp2tV$DI`2Tinlp@-1huMkI!h)^D7=7#W6?O9KJkx11+xU+AnGDFSw>l z@qvQ-d}eukhKPPDJU)tF=kRgUwc5dFiYz?s^7zYb&?Oftr{eF(1?6=44?5K{)%5Cn z&|!irAH_!r?x*)s2Os0exzXc4PxR34@mKs&hmTuMhMab+oCk$ZD7eb0_$a}BIV(Iq zq42rRy?x~1u0BVdZi$$#%N_a(!8IS7G+lzL zeiTnQd|W*blkcR;M+a=91Xn(aj}_e4^HK+&<;eNC$G=?U-0I<4Znq1r@hbfj9%Hh(k{&wT+^j^ zh2WHPw!6vcSm@-S9#(qC-*5H9=+mE2u?lBb<+EsgI75CE(gEH!QT{|>Alv$y98&tT>OZ`$E|n$ zi=_& z{GrE3^*PGpqxfitkDHH04(^td**Wmq9C(+5yX`}W1vEUE-p|`h^NY3r=AfQke6~Yx z+A9e&PjJ;wt>6idewXO8#-mrfQ*i2YlJMZ^6^D;o9^Mq(FAuXQ91fpPeGYuH;M9Z5 zf2-g=|Nft{{I#5H*Lo_r>Ot{Af>WLuHs~?G5#WrfOZeo=Q{seFKLb5{qtHup5-9yV zp$k3w$H9+B-27sWoW#3d_>?=iKnBq=sr+@`p2nlN&PUYzS6t^8HhKJuM4qJ{uJixe zJY45luFiqCd$`6Y*?63P=D5)7o+6qaZSxgZK5ZVo%D>seRn8|oT=jp@!!;iVi9R%5 z&G)GuuJb|bJzVwA`FA{&kG@wgluT8;v$v(wc1Ur}uXc}K=Y6VNO0V-i^J12t;^}#x z9==-Mv*;cmO0VTAl|Z(#QyVTCSCrfP z?0@+-ra=gGF{>mStn%<1m#a|P4SkTW7jkCvmxsT&-0NxAM0>SV+DEFJ@o4xVLU^v= zl0AY3LBfkyA4sv%TQfg^JU?mpixHMQrI@ApYWy#y5qqKXD|`_yvZa6aY)erq0yF(A zIvQTn&u=^=8IM2rDEzd&`>iLKhF3jsY|86GH!!Y0RbYY8!!?|qX%p(TOZqnw-o<$B z(=HUu6ElcQ_%5k0%17nb`}w%YroZhnDCm+1sXu-q(eSE2KKA1V6ok@=u9g6NjX4s3 zet3SC^2-jOVDp9i#W#0Pen0(uEtM_&Mlt4>7%rI~KRkQ^Pm+yILmt-8uep?Ki>NQ) z;_*s-;=X_rPNZ=o%KzW|dt)|ashb200k1>FJEy> ze%!Ago>hS5{gZ|ti?HPBw=HpCJVNuE`O*0GO#4}{GgLv4aBrMzpO*L8>b8d8EMfcL z%)b+@+xZfae8Lbe$IF_lZV#65)6yaBg)cwqcF_b|mCf&;s@oS$#OCpa^2FA~;=27eY$ofa>Cws(Blvw59gc=pnOZ_76X@UL<+rZf$QFEtdDim$?F%y9U+3(pBE z9zF$rn5#;5sDG#~$QVB_*!pnQ@?zxY+V(H?=_cP&bkPr2eb&UeNBoV@uNiz3?3e;x zUGV*vL_7$yWA_C3h8_`YodCZD>w{q1`-r<`Fnl|F8on>FCoz4Ut%U!XXg++bK5hMn zP|j-X+pGSh_5f$RHSmq~%xOV!%^;iy<2(fCp+Rx=uz2y)pEgr;HZVShBadH>2#TK` z5v=<*{NHrN&NSGjd&{~D!r&*Ezj5Gv=#bBmC-7l%Cj5=W42|`%ZLf!)4WF{3;70|1 z@~rQ+!SIz3-?9FuLC2IL_@+a-c~a847k*jxLDt=|q40NOWf(p+vN(@EcA%3s_}tm^ zS@=5)q6eOYA2;%g!lw)Q-9mmSi}b6w8~#;qML9!Tg}fL#X73}`x25vh1e!gQ>5o2` zbjy%nEBTUVqHj=fEBvxXg6InY!dJnk_{!S@sE3m-M~ zO}O%2;=}@^lQL6h@b6JfpBU-#JQcF-g)g?KEzf7;*~h7GUEtaNal^p>#(IRI?2ygK zjio5q_!yj5A`VLn|4{Nv~_ z4qo(8ME;D2X>{W$$1~QMN!j9q{^P(Y>mK;7ArCiv7vw2oc$7Kfq+=Vh@~7BO@K-$( z>95t-X&gL1lLZgK>m1<2(a$8H<2dd^Q-{xh&-P>W!?HG%w8jt6qv?L+F#3dVp&zmS zoAbsz`lG+!*$aMJYJT`n@80nI#cTHc_DApTKd<+qXHM>Vw;Xpb*TE+db1lo-PD(}>xX9ldD9mi zUH+zRYf$#W3*gHWJ`m~eCYTUZ&{rS(pRRGhhoMajQD4v|VE_7J%C>uaP(fev?E`{! zAHuiL{kV>-$mgrR;_cU8TC@jw)+T+=^4Dye3_~m3CS%AlXgJc57#&nR1%E)x(9RV^ z&iyp~RqcaMIHreb*LLp760{|3r{~%>6@6C)`IkyNUBx)SudR&j^ch?BB9GZlhv50U zYWUR^-{s10Whv;cvTbz|KCZ}ncn~?T3G%cKg{yANy@`Y%v&qhG^ zECUJT%QogU?1>P4?M$@&aqwUsvEK7}Hu*~~&d6Uf#mOJo2LA%Ne>oWWQ;fVqTG|F% z->jW~Yx5+IvNHUm*kY!wbBfI$trr2(cPZ0{yi3AAX#)LX=Xt?omgz3~pYMqs+I=_c zUF7-#q_-XZ>wXyxezWpC#5*#$8279P#jFSS{7tYG_Q1~Hp^ldTN4n;08W0q-9Jlul zidl}S1HUXsP`{|N&cBPVXL-inCp(Ota3O46=!rTk1FwQRwPq$R6TZ z0)6^Va2-K=fqf^&XdGQ=BNFhpe2dtIZH{et3v9zE=#_T&=U|h--YbR;xC4F_P72*1N39VX9tH$Y7<4t+OUXr=Ns7TmF>zCIAi~tb?}!e zeMF|7QGQKJdvx%cF8F(^mUbjt8&ZNiOgL>wC+wtZ&n`=5v&-m*%xN$GSR9*Rue)(X zj=~Q!+bN_uf_ygZ6vi|7Hd_%x8^wCScIp)5CF}AlNQ1VUQ#_mCqu#+p=J&owqQ(w$ z^Bv{+q7dx?_iJIA{gsRZJSBd(PPd$zHEV_ERqF4_mJkb!And&uz^bp-ze z#&%62|Es=|#dh^{lupA`)cY4QcG|Vz{dwqueK+&>Qd~C!bIVWSt}BZ7JRM!fw8nc6 znH)#i3D_4PU7L)(9~6Hc?Y;?*bJw@xJK)=PC+ge|E#FKR%c<6TmXCRehdSPevzBp| zt1kFoBmWO^9kQIFe*X*V@3ru``O6PthrZem{jAr&QkP@EhkYRXKFV?f&Md3GPU*Wg z4th;P`(y_f@S!X#Xk3FYc-f@|%#U9phJgh&z>a`-kxP9o!sWj|E&mVS9cn%HO6j7?+`pB-pN@4~#zt8rbOx zl)Wk7&2Rzs$b7 z0on%SQ;76`HjAurJX;4^)`JAD*?xY0c(CqYG1k8JOlx;tcQ(gvL$_e=l4+}HQ~R>C zBh4$a$U^?hvfyo?ZvmdGE)5@vIt`jx|3v@Z;-7Ta((UuJ@ajZ*6Ts;smHS=Mzw2@G zf#!2r!ZOWQ15dXluu0m!(^K&zaOCNZH?o9bJ(~*L&GR;3Q-Hbk=*%qorr-WaphKF1 zLHOgvVEmndzti!@_xY#c?^OKpNZM2SckWeXm(QJePRk{5lxNq_H!PrcxbljM*&&va zFI@(&ej)u4S|@sz9>j|lEoo5ag`fwAb85gu*Sfjq~Xt z&>rQoC^|gvoR;Je5}^3as1P1s1fJ1jKIU@Fdem#Qx@k{G&Y9yjfliN6^WO? zLt)63%W(gfY&Z`d3|msDOgt=;OOQkf$K}z6);`bp$K&E-FHWRn@sdkP56# zg?3^1xc|!ZsT>*h%qQq`QAp2_5>DPs?v6IDLs6QfLe-p~E@zWYwAM?x1bxQ$C#p2dJG?$5t56tB z6;)pYEv)PHsfGouwc+1}<0nlDznH9UU6QOP_&4X=wB&zK1|Byin;XF95;z%6`#lYB zNY*b&g-yv8R0~#i$IPsYieDpQ_hN&+>sN&X5+ZmZ!Vnly7{ERGx_7{g15kJjQN!#9`T$Lwk~V3btX+`I(nxU{S$k34`d`bT>rPkbUp=*P9Aam@%t~2sr-Nq z|EG}$20wU4>H0w%PA|KA;Kox*?>z0UQ>WiE;NFv`-Pb?*031aAjD8)}(`68}Ay^as zc$js9B?CHR4-`E(xpe)-8zzha_@-dw-1VS_)XKS<6iIsS{X0r5TFn^Xdr^INj{5#(|- z*N@;RLuY?tfj_fA`5cckL^eNvHr|trP42KZm)ZOdT0Z>Re(b^djr5zPhn6Ewqai*| z9+(Am(%c49or|CKHYjfZnCuHNZGzZQPIN9jGmIJ>h2hJDh+4%fx4*c01_!~L! z1Hh>_ymv8&uCx7p4*Eajz)wb&WRo+X2Qhf!3PvrZ6RrBj#)V6o#$8l6X+n|p)?*r& zO7(PQeD)YUlTMFA1RW5;tBf2rOUbMtv zm5IstPpWLHPu4YPh-A&N_Z+HOcSosY%QCn~Yc@{Jm7I?&jdLT5*!GfMvFM@8I!$V6 z5U)vaQ`TD9)C%8JX`k8r*upxj^Gpw$T(Ij3TwLdpa9*{JT}e6-_dJMmT&su9qgDQ^ z<-shW=e%w5S3KeH;W$~3#~qyGX+540T>0<93s4@<2(J7U-|z5o`5$(0j?wkV$BStm zOc%%RdZ@2#;%1O94~lZoFLiM3dl=*y2R}=h<6I=^Ab*#>O>j+bT*9mtT+^%gT8EFD z-cASShr#rbXRnmM&M~4NMIMUVJIp~6T;o;x{vNLMLp(maMDN2qdc{M*sRvj7>pVWQ zMUOQeAH|nCeB5%o*5gwvdfDjlQT(wSe4g<5s2(~!T=npb$6x86^Khkq(c`0S+$$cv z;`;>m^>)zX6N>&1dwdi>;_z|xHd?xL@^|aSr8)3<4(`?$>?dgsEmx0={_6$Ta;3QX zCt|#=JZ&DImqc-^JU)uA7To94?(sPy`q}L9QT&MX!Aa9#Vs2-N;j{_VoQ+~cqK zEQgQF|2n~yPau2}9v{VPa`0L0@ktmh1cCaQ()23Mjh1;(Z*Ke3Ura*cGIib1jdF0e zUd$F;wv zugiakq(k|);W>|Cf-8T;HGSmc@}DjAKL6Do|09wgcX<32U+eI3`48-CnF%95BEF#UAyQ}2Y1V1 zr{Ef|`UzA2I~uRz&pCXC+oYJ^LOYO3+XL$Nt4MI=qxhwQQ~$2~uKya>?ovNBq<8iC zoWsY(%N@Thu069#a7}Ny)T=uLS2-15>+o^&ckF;nK8B7St`l7O=S%&m5nTBzUhD92 z_0ZTI9UdRWH{{@RzsE=I!bd$mia(Zv&nPj# zm|oY;QGYi+UMuuzJxKYf7d)*8!J8cZZazNh@oAHMe9Ysc_*RFHtIwA_J_(8U6_1bN z>VJpna^>0Y@liWc{qJbH6hG+5hUQTJ8Y@PNAa6;@VUd|qxQ#IkB{OTa`4&g@liYAagUGUTXXPv z#^EDPj7jfv4j&ia<g>0Et2g9O+79WD8y zew37t;=^+ADfjrO-8oBe<)irQ9DLNjlFHL5@+3Syir3`evr2H~qvM~|9v{W;$iYY3 zWL@`bG8aFEa-sMAT)}0yD}nI-&5KtbkcWGW#SM9W z((o4{EP2Xn6I|It;~%AfoK=2>i*dp5;}y`ebS6b&hbye%H67)6z-ujMN>?NWGE_j$ z8cxqw1J`SpbeZ2Kch-EL|5i>lf7-7oVy zm)+wf?YKU+00a#0m#?@VQ11P*bslh*_fHz0b`N>_c0(K(kI?*Pel&hPPr@U;&QJwG z!o6{>eOliCIqSB(MoCNH$DgZipZFSm&icz7$JcXQlI!5{UJ^@iJO$f zu|gk~O#6g&!*32cbZvcXYRQi3Ug6}U%fD;aM)nK3-^0BB*xHirpmSPxXY9zgYwjxP zUKIoPKV<{V-rU$<+w9EE&7$WF2wwjAFG>f5>!T0kJ?Pg~2Fe^Pqkqo1MYc}(HNnQ8 ztxaYf$u_r$XtupbEq#8DIYHVxGj!(2HW!KS-`zPus_&74YrowkY-nmLCXhLC--&Ga z6*=&rr74xFF_S;i6I{%+5`#M%m!-+<9Ff%0rn+X?+N%}&*mKUbePU<3B#bon-L2a$ zt#)vE4Qi0>4(`&wDLCI%xcyF-;Cy%D;`q3_Z*IyQb(8D#Ho@e5@Uc00ZWCOF%en~LjE@+qV z3709ZReps(kBe;i*Cs-& zgLS`xUxuEZpo2C<*}!=B3iywC5$j+#aSioo_!bHx3uobe3)am~&5L)}^un5Lr2|br z*eACN-8W-cuM9p<xkQS9!9t*&U{9k@sQuY10RXB?}x4S zYuHt9gFcG5jxPV6vE!iJ4H2YkN|1jb0e$@tX~BBs?%e@&%Q$0ww!A$o(y@P3wBzXV zCykB9HI^%28&>y^bkycWjg1(AtX+8s1Nq)VoDt||N^sJ`mC#=V{xiDrA{`N|sgL4% z_rRcg_vm29jQpUxPye9%H=tL!smG|u3)$EluA{7!{b&qp9rNNHOoJ=;V~{(CmVl@elC+zG5WHSYGhYZ75Te`)$bmYvcuG=Q`OiuhiJI;D4YDHtKHZ zdq3pvf&RM?W}nejykk%Q(vG~7gKkv7?k-@FUXcIfXa~Mc!<|UmoYBOwE?8w8$+C>K z;K`4ADn@}H%H@G}=;0iMCH zWxlw1Zmnf=S=WG-OtPV|0Wg)k3Tsjw5-#DnAw}kB>_rZKuaqe#20tjcZ!7EkWZzcq zFLL{Qp38yjJXW7Rmu($4QeiX&xyVxWTJPbi*ZVzO_4*0?11Z1FohBiAu25X!z^%Vx`M7l!P7czj%2{6#Nb%jNhQ zJQfcqlTUu4;nfzG;-k?7F9}1pe)FN9e*G?3m=0+#&<~j-w5Rm16!)}ESc)f#rHObU zw&XDwZhYF$3FgbM;X6GBzWj6WJX`+h{IGPTB~bt$e3@K;#_{~m4DS7)yvUOWSIQIa5y71PaD}v}k_&llTH7s5<5`S+U?U|HB_yoc*KFTl!v@t{5Yhf4s zrqPyZ2Mui=J|A8aEFKM?9$!b8ujBq8Y!}M)5b({g^Ax8IN;%b*+k|ExzHhcv!nRYs zNd6$E>-)WeiKB4NgI}HzuvN#v9z=_~2H7^KS8ZKU0sI<$KTl{t+XsHe{t+^*#vjx7 z2xR#sQXXMehN}nwc1+j&3$l5O9n66%+ z4um)VcXE*K}H`TbV0qm4LkH3Jw03Dzi!SUq?h;S;hwTlF8bEv*Z{iQi8?u` z9k%JH+UlaO;Q4Kcn>5rRWq%a%<<*WX;`3_yBg8x3Re$K2q&9I@K6!@EsUL?AbaIOrjPPU}d zR;PK1+nl_yvbAwZ6Fw%0EorIfGbE|6Z(EY{Q(P0s;Kx2_ZEna4`Yan-8}WexahSD& zUd$@=tNgS|B=I4tSl9`H7=EuiW2aZM+2*VfHtbE@s2HfJdDsa_S=e48iF71w<8 zZB)&-HjiHOjrqbu`Dl7JTR4qtdOp5Q`%|~k`Lv&3oZCSNv`CP;2vPI*P z|BsN^IecB^vPBO{7r^)4?%{`rEjoU@eGP1WkGD%LqTi}7DlVL8$xqxCZPG>=g2at5 z))qaw{C{^qO>6m%ts3tx-@~_Qd_Ttb=E#;rFy%FVr%s@o-_ysw+u}E1`_1`j^FEW| zk!5m3vL0>*xbnZcX_;6IunwA2 z7B>N^kG-4UoRZg4roEwveE;P3?fnVj;J$1wuJ$h9Cn*i-rt${|`M9NKmW2%;7jG4u z^zJuhwSO6}i|4W(;=)J!aJ~P(y|3OV>C%(7^?IMHuU0<-n}v{VI#hXFUy-Y?-lY+E zXYz0lmIKP<_w^?lK389@;X^kvTxX1t#VKeL6w;^!RNf<*tE z^z_?)3~ewVJ8i2+*O{Ge58mq>UH(LRAAt8@4^-fNjNL~j81wtH@of&nL;4Zk4SQk_ z{LR9*@tD`6_zoAfd!HmQeJcT<<(+u_p<%F^7I&;_aWN@`faeRCcBe_H>S;#C!%Fq6#-jAPKip+66=`dZIR zKQbOOvxKm6UXiSa4^YhKM08C{TIp#r8AA4O{*s1j`t7u2!E8FpZCJ9XN<^S9%4ArR zs;?}TG z%~a+E@HW|C;%~tm)kUd*q97LP*XU<#xQNc4>+2S#;NMc+{K8Xh^OCBnx|Uib!!RaJ4D{p>N4= z1c7R1PIZH)wMYlC$7mAyY*S`~W#SROcy64u8m7)u;Av;9{xb%}^TsCT7n1;aoS=p? zo*OUO{zLL*)@H%sJrjEKA7td5-<({)ukBe$!1t!ch7_FYW@k{EgtuWhpuXh73z^-4 zxfh0vg7@mTRqx?t_2N*xeTo={uD)>rlFN8(I8~H}Yf84(y7VSt0x%vaY6iK+abYaQ z9fhj}Q|xO~m{@P(V+JWdtWKZL3jpvU!;iVRk)S{K17b2J9j0R^_54^{sW4 z_yE9aJ^K8xrP0)3jn_PeQ*w=0aXJcgV91HarU6x3S|z39GQep~op6v7>^ z!z+Zi$$Gp&s9DCG)4P=>Ff5BEDS%o?Q3E*Ei*$^h1n(Ea} zJ{9fC;g%OP60MEZjrHUwK6J%Fb=^&7Z3l3+C`(%CbQ>aESXW=4S^y<8uaYPL&EcXt zcxuK|)(IXZ>i?Shuw`N_TO$(@16akI#IdXx@5ZKqZM^_$bBc^`OuxGGW2h2R48cVNJ3%X___U1L?J; zo?S9`u0(2ZMv6ug>K1OwgHHR+Du=LfiGADT^SRdLqx{E@pG<+9&&$q1U`UsAV zO{sp!1k zccFl)kTDBV>H1rfs)q^0ToT{rQhCztG3q0H#x6pMZ8aK0BS;tMv#*+4!F0}@J4+ph zr*%x+t=F&^VSL>P53@-%XWZv(8cpW1Z`KkrYibE95(+RInW{SM@?j5)x1^HI)wQk) zY`cXeL&zhsB()TyVP^N0PIAT}J6KA2U<{^=n=F!QNtfW*(8EN0r8Pxq_+c#)icM=v zSc_a=lw4Z3XbE;mZ<1OE4$`^S z*L=FbLoMj07KEc4U}&LmVXu#|=)6toVhJ?)(!30gbddy@E4F9PBptrct$%ma+~aA{ z9Mz=eC(*TADbsqQBX>rt)rCa?E4P}B9@)wm>($n(G@U8zX-dm+wiGLNx28bZ%3(yo zTvgQg>SQb0igY=GH4|pq0z+5VRGV&)2vCr)Iun}R)!ez|$gxFiG!~{ZW#FpIC1KYz zK-k6w4Rtp`<)CLrZQ78sMpz^;Hi2ndcEPj;G$=?G!d@Zy&hi?zAat0*t_QH~rJ!c& z8zrkp+lJQ9G#)nMx!fs6S`&1@)hS4MqZC3EGHT1{n3El_iAXxAlviY{cJh|*H|xx!&J0`s7bK$paAoA#;z7UHkHbE zrq~r|>+GshiBGLHT|tUri%oto$L5JqpBikbrFAW>Gp()(X_~?VEX{m=Qr0asBLYTV%up~j4w+}Rv|yMN zngx|%asixjV|034!A}>L_X`fK)=)!tFlTSkic~cxKNH^!+HJD1J79^~ht8l-0tBNn6>OysSXMN1LjB z3c1$TEkZ*J%NvSJ_lMMX(~>IK$);X&Y;V$KMQy6Xeoq(*rU?SltI_4O5a`5Pm$Yyr z7Te-5zUd`1XHC;`I@i`elQQj4*gjmC!!APm@9njc?vB!JH=5qGrVOtMnft4+nOWv0 zUJ21HU|TJYqcD)2A2IqBjIDRzc`a%r}H$92ES6B}Z)F&HIhV*HNA zL(jzG1aOSDC-YsnLar5y<6Z~EhxrU^ULMGQuutjw-Wz(A-I;e+tn}_^>K8wM-R>@d zMKF9o{O%~}7$nz$?<#-RZ~OgC#Ej+mBilSb`yIH~am1$qarcf;A4>c-N?h+%Pt-f{ zwwPsAXiot@GZ9yx(+36TDchPBD^GS6X4_N3()Z0V-_g!=aH2Gq+4i!~`HM=ciqj;Oc z$Msdb*1_F)gv^{x15!8MJF#{~~PK23tF{*=B;@IsH?OlSaB zhpZIhqnp6rd#Dv-_i+>{yCwq_3$HtH+i_O4PWZvMWWy~4{s8D zwTEvMe65FX7ks0K?-IP-!{s*E?BN4XvcTgWUMTo>51%b~r-#dJ@SKOMul1Kae7o@3 z<>B-4EYRiQ2ZesWhs$l+pM~aQzI1s!Hn|{C5dn=;22MFY@q#GEpw>;VOT*hmRKe*&eQYL+D%}m1nbi54zg^feZK*65jG;f3x*T172f{3-8mh<}C|d3k?B@TkFCEIqRJW|i1XPCh! zTJjSOUSr`i3@&jYdS)3sYRR`4T;fIKB`z0Q@)Cb77A|oXw{VH4)fO&sv(~~TKDJo6 zGUu|cmvfkNws$3xrXr+$aoR^!c_v|z*J2MjxnRR1aDh7i z()7IVN1djb;>g{SCZjeJSAvWEay}9V6bTAo_6{Bx=aw|{NS2>NhNPGB-vEqRjl!RI zi<=4wn(Zmn@Luin?9?}MOFh{X{YD%+KwGSs?fymPk7?l zY+rHu)K&VHtK39G59XSVO?)aQme9GAqoR9**-Yxs~Ief9n25lD$v0HF~N?Un;@B#B9$5_0^C6W2e6YB8>CDG(G!N>a_cmATVx@ z{O;q~$G0{(aguoo6yKx0sBUkK3B9P4_YB zt1~Ix1KWPI>GE;9HM{?OQkx!GE;K=(zD?(O#-*S(BZ&Li1?t?gAL@6a_#V_B!Nd42 z-izY<(tO97??k;9@DGRh1`JP$-}qJP4Bx%RJ5X_@%CN-k7riW4-tN=1)*IT==`vm` z-m4asfNSPu@MZoZ(gevd$aksl3h#PPzt{95{a(}2z{SHm2K&Gd?!L!FK1K9@dy`jy zCll#f@qUzpwBuK+MeTTGf;isAI*DM3DB#aQrYpVK^7}OX7s{kJ@9)JEfynsr7O#eS z)jXEJtw(rc?xt>)>+?2r4{y%79YloY2i{P@ZQhgW%muBv>wg#%e|{fnw^&zqSACv4 zt*|3c=#7+10$XbUKp!ybkonxJO{wvoy@INnxk0v-0XL(SG%yrUEjJuw)MoH z8fm)zMpw4s=6{BJPwLGSJJW~CdA51ItSiNjoIf!d@=QW$SJ~$EBRWGzveJ7S<`_hs zc8mD5={YZ_&Qkn&H%ae!K^#l|vd{Jo^kfmpl3w7cMyEZF)tK~A5j1=8pTIZapsRVY zth>d}^nX`lAhWUarf#`!B6e^r7_y@>XXiYY`0_^Lw6dbcXTGzM|S#a zMvWOc^3NDU|M#0%o(X~YwrOcobK|^PJf}H&)c-THZ-eRG%pviM;<={1eKM(@=JcHy4$?&QkA zI?lH_|4uLOhQD0=b;n;G{(9gqAAbe->xsV$b}>)&^+~CI|0kG2hrKt@JD7U6GO*6) zkSqS8-RQ$LKS2E}>;TSV{MNR&1o^jqJ1-H3y?vhyr$*RYW{=~ru*k00l(qZNL? zPDB3%v6i7dN!UW!(XfTGwC4@zXu|i5Uc=r&8RK8hOFW0;Fu%D3P6+Cv960(H#otRu zw&&+1w&(XtBp^c{GcB*PEI$QC9*%R%ez1!isEk3z9OLj}aLRwDKt*m>zBR`(>p$P_ z9OS_`V7kVB!SZK63@lpJZ`Ic2s{hGWaIkI!M`{Z4jN@8$(aB&Bmj?uOjyiDL0@sUi z)UhABpsx?^()4S>^`l7l8-L%EZ76>fYsL^bN8|SnDqrcx_n?qZ$4BYNs(VYy!+B~Q zNCx^3*K1Z?_dnKk-+}znpLMxH zuqIvvzL4R`&mtC4$4~gDzyHt&>4^LNgZ}5m4)vW|=IS69*&)WXWgtovvZ~)aezX(1`_=Ucwos;iRIr8VDHqOZzmszH*uRGuWV&<9ezY@uJ@|$3$8>gH>1}G! z-=ZFmeJ^n9^2y*HMp-Gtdo4`QJXn_BKyDu7o;PxM{wX43M_6^!u|-*?2_LCH%QSXg zUqQK+-&TKGZ{${m)>P z;y8r$Mn65y82j5%H{|MJec--Pg!NU6n0OAi5cZ>wDB+l6WZ#9I9ccS`=_h-QuWx?kFPYn*HLfB{Z-3-@vPeA4<;>Y&klfaLmZX~_;dbq_+yV0Znyz58q z)Ah0y*VBQ^e|~P6Z`Zj>^b0-bRlGCZ56(liyD#P}@7@(af5y2**K>;W@?N;s8-IoP zyAXeU@YffA{qT1Y{`%wZ;$4?uoT&f8)KrPDbZkT2)Rceo%EPVQRl*< z=8IAoU)i6&SD%AE*u6LS9?EhI{Sy1EV*!mD~TydUNH7RunY?Y;V{ z^X&6se$s?-iuQ4wr!CB1=3ibLXfti3><6RWaia-i^FLmo_HthJ2x9zB#447#7#D-7 z_23pqET;M+&G-G6t~uhr^dRFCtDrRsJ}o|8{PqFFclsT*v?DM8-wn#CI3CDZckGxC zW2%20(^8&u0ypL_-W|+y+xBlEHx&Lk4mt9v(@*ozpHhC=^UfOP&-|G0JD6K>+-WMH z--@*FljsNO;~dlh(=wg*E&NZv$~-fPZ%1n1`r+HarMtbposz}3AB@H~b4>mJDc^T> z&6}1s`Be~casK$hxfE?@*=f7xlQ-p-GUNU=A5rfz{SsXJKH}sh)Yq1D{4ne72f)T- z91CL1AwL)S#R6^dJ~PoSI6mi~?Qv}G7GHUIMNUx9x4xvht?7q$#Cz*27gj9Yq;l7U zPK>JPo^0*Y1L=luS$X)&HA|OnRz23VMwTvJsq)wS82$gZ_Y}00V87!~LCfErDrh+Y z*_-jlwFuk$MwPc_^WDAi{i%XAE2F(r`~9Wk;+U(j&t%=y!Csb)b;J4l3Y@cTJ$Np? z*_CtKM%c(jeP_R)8RI-$WcBLegKQ&c>py=TX@BSO8THZc=Zyg-E%NSnzHj^Lv4t4x zCKqLR6J4v4ivr1q`AqBisuwWk7$+R@L~o(U{M8s64gi#_;Z`4`{1 z9rK0}xXx?D)scp?PCz})d1eyd7NcDy#9;^Ps$oyy*6kP{hanAhxq7{GA;R^B5aZIf{eoR%I z`5n0D&V~{$cddUo>+#)_hK~+)L{2zx)uHd{{0{1O(&^2*?lgC;aL9S%y3_akeu8Vy z_cUkjVDt-KdmQA)HNetd97p`S$fwKscjKB1jk`sXE9yJWKsmBjv-E^`Y;~4v4mWk(FzhVFOSNm}t z+#j*lcQ@01+mxm4O80vi(fRmRZ7=mSufygI@j_L$@BMU{pX(N2j0JEU50`%F#1#|f zVLa(#4e>L*4oQADw6s0deQd{*!Nl>wfpzsL1LhYxf7-@8=*!|N-y#QnJZ(yTkS@bo zZFuq?epgMsJr8S@j_JYF2Tk2}U5fHMO0DTY-O-*7_>(#w#Jvp#+s-0Q0Ck#tL?z;Z zz?$S;s8?_*#=m=a;{Cv-!%yJvNB1r(FD}IVeSnJKIpzq*AUux}aUA#nzHT1~40H5W zwCj$Wc|W0>j@uO&Bj5b4N~AG1@Lmenb8mh(m}tc~ukwbj@#RfUaE^}`GxZ$bxf*-u z=KOv8cLyexbyw>qbO*m=;L?+=C{yy0V1o6&<9gIPenV{QfqM?Q!9=u&Dr;bQT2~xq zdGAC%UvivvTTt%bU#HG7ewKGvZ-0og+>2OqP`7O@%l7GVl%d|2xyQ*-$ag#J!Jc`W z@271T6v$f_e&~yOtrbIk7vr04Yfg2pd8F<)@*Bk_4%Df%{+>#Uini)g3G zXG2R_w{8E?eQfgeAo}+HyBWKzrzB#Ozn?M|Up$$PoW-|O>X8P|`SrdS-)D{@rcZob z{j-*R9qsCezNOc&?dSDO97R3s*Yl;myI(^ca8CL`Q}wQ~yk3O075rS^9d$Plb%?&W z*inmOXHc$Rt~~r~dtgy(z_%t|J2e&WkM$J#$KWNXAGD2OLsX;(#tB`|ce(dm*aydJ zd#C=kzIW=V$&+<|;)g1+9C_0(w_sdh{W~b@i5~_Nan$j%=>MJ1s>r`%tbO(@#stK| z3H-$&!|Tgo>$4{Ui=xAE9b?9R?1Sc73$MX02W^yg`eAo#z`us|GYD%B+$UJq3Y&0m zqGBFoy|MY6iOm^VV-w#+H2nzIpKVx^GB!h~1H`=cZL2BgO6Z6{KjV{e%NYF@VsbzH zrO?LMwr;WVf869>jI*|yl;kbe|qjQ$S4!{<#*pnP-MufTcU3~dMF zIDRSC%*LKt=q&Z*S7&h6$3RowLGU5#VujTfokF)Q#*uHwF|6zIBKSU}e~v;7c;jgT z^jwTQ=>Im1wa<=0>~Owh>PFhCDqKB)<-dUTps#V%J=+)yjQ19=8ZzlWt4S)X; z=4geFXjwmGm*}>Xy`N-X!aQ1yzuOVF_;%6F&pqd?q5gXG@6@Z#q{pzoWIxH+-++7= z!}!Q$#Ef$B}d-ifi<56tT5DuQ2gd_`nAlUjgoe zK&JJV=|~7NumN$Aqw76p>h&1f)n4eNd@K4y%KKh%WB zMn2y**Y*cg8T*XK&3S8{E4%+C+?Ub$y7Fv~w7tE%Yy1AguwC1nlUOgh&ZTue9X}VF z-Lx#<4rB8_!REh#Jnh+Wh_<>iD}b?HOOR(*^%;LNJ?0_Ukge_}y?%bXXPvTsSYB`b zn~?uKz}c1?v1eO~(YN%^ix@x681@nB_w%^!NBX<4Uk;f&w7g1)|Jklqn7-{aY;$1y z@2?A{7%x|tm9*ima=*_7r zHIF){22;$pGks8}S6FW|eGvV&|0n6PYhl+>jBiX&yO{p-CjCU(3!509pT)7np~Uj# zz}Ppk?_!@W{r81PUyN&QCN27o^ZGbx+x>z6Sh;PF^+p?>H|?+ex%3zZJ{g3VdG3XD znS*#70(l4L+Sf0nBjbTFpFw#w3BQ&pOkAdAYP3x3dCC+fE&;|^V?Acd3Ev;9#dl+2 z>#^EkihUaElDa$oIUV^L@l-@3!gH(?$$!QbR$?e%BZN%K7}z z;deQI_4%Qr%F3E(NF;Jc4SyemKmSN z0g>rT=Qo39MpHRxUYEwX^Ff8>l5kz?AV+r#Pnr^%b_aMA4UcZKSFTe`O{=`UO6#qj z!nLm&+T=_MRXWqd4$r^?0D4QX=z-HpGp+Hu#)mF3dz0bN1`R8cd4c7XDymDabkwlw zc?+ADf(@z8HPO%)QO~d?ogAW9x~Y+W198p$tFh0`ZfKr`ay2;DITIVnfW#A}oJp>O zkj)epz?n2w-rhAQT3dANJK#xg>?3=xl6Lrs~V8 z>Xy*7n{gi2|ANoeg;mIuFLZ|vH&tySzgm|TkD`aP8Z{j^^SB|B^uD@sqE0!j(p5D5 zwi@t1fu{1tsZMBOb%-&*%~ZRZ9tlNmLx@Bs-7;y)jgGMfyib)8ZRwQIRGlOCS|Rq8 z)1U5^@U)`>Sq4&hFkpni?j9AE6EXL5LNEb0%_3UqSu6JavLIt-5k5%~g?5 zWvFtxbDI#9xr%goQEpt1+@X7y(WAzdBGrwPbgMwWGa4kCx*Tp#qw|?wQ!NBilP64` z`Z?&IJZVbxEmNyZ?SlVxa@AGnpC(Py)*%jVi%dkDpOj+zMju}-;9@qR%e z3y017e6EA@B7)fTb7rAl&SN>-0^#-k4L*E4iQi7T8`rMa5=yPYBp%Q39tu2m?Y4@l z&11HVzGZ#+hH)FmZYsNL>&S;k-TT_B;fF_U9Xb8AS0~`v-6Jk-6BCFS(@=s6X21Fx z)IEg1M~(iyn8ZVW^s%1X3aU2dZR)-`cT2bG4L#Q9S8feFob$zBycBxv)hbsrzG2=g zx;}qH50QH~XKR27C+Gj-rOMY{4Q0d%!Y}>e)z|niF$~I@EUc9))eI9d&o1U@d-OBQ zH}Y}i34CxF&n#~V+|37-rGN#?&O4iO-r3Ebv&w?mp0iNF)QA1Iy*lk-f9O^HVB`}l zKemY%D>@Be`Mos|E693hrjLL`Yrz*`M>)0tFIXk7gTQf zJOAdL{<QCnAm4|+l zB;U@Zpyu@(aaqUNPR1CviS$L4%Lg_|Xum)QHkS^RVrx&!iTnJsyw~}b*5dN)d}wqs z*5FsoF;+#L6F25ih5krbs6Zug8TYmImQ#RTs8`bW*uZU+ADRUp zl?A^(3w~o3d|DR#jx6{WvfvA{;16cOAIgHaWx@FaU0443aTfglWWm3c1^-nR{CF1p zqbztK#()d`-Bc3Sxvh0~81VJN&3y^RJ+5uQ2P2ebQmr+JyS8dlBx)5*zu~xWF}{X^ z#n;tjGQWDH7Rao{l)mbwb(79-yk`Lj&ov)kCNnjp!B`>LxR>hZH8dIOKa!)?@{5PH zpxiazOw=Dh#CIA%1?@_8Qut|Zz$Tptl;yA)@AAyX7ZWNfYMYwsWAkTr`B7%P`7=NB z`9&_pX39%G`o$mlNTWVkxIpY6V|t^jZ}$9|3v`;fjq`PRv%Er754v-H?$OnB&*G-r z7Q&fE35v61VXY7YyE0_T?UbJ0*j!~;!@&a0??brP<}bM4JNQPjt*0RFXDJq&n%0pr(8P<)ujd$?{Rf^)$!sIc5&I7>E^$XaeD_DTJ?4OV z`U;3W`%i8cS@<(9tly&&+Xx--;GZ$a+#NT^qTdXM>V$}(c|^o zDi7}HoZNq&GPu|uG}mN4BKZow&!fj{f4ik8ZuA^5xabl5#VmS`SbA0)J<{Ka9>Gs| z^pqG`?oN4d&cS3GV&>5Fn3b9J@VxSXZ!Wy`wY%}hj`@iJd56_$J^fD^62s6MLDiK z^$hjs5gr!t=T38NgOL}13jV0UMPB-mHcMXcy_Wnwqko?zFZcn2(@wr?C|jPH!b-m7 zxX!Jo!NpF&g%8TsQ{&Oo+f||ejd=8U@fMFf`$@;-8~4b2@l^)5^WA6Zi5or7Sb7A< z@ArDM^_;Nu>@j-Yvh)a^m)o_TF$NcZo^Zv~^#&Jz3Lea&XR@Uy&)5^O^a$Qy@Bxs! z+~mn!v!!RE(esd{NAO3p=xMX`958w8wDbu6l)-I3zhLP}8a*#sdIbMP7Cmoy^myY+ zzVA*yd-1a#dB&CaU%w2BbGu&h%+kxYzo)^ae$N{F`x#vH2ws#$&j?G;YEv&`EIoo( z8QiYl8cWYwqeu8`#U8=$Hu844W?6c+7(H_>e5b(|8eH^?e6xj%{3=UNo6)nu;I=*c zEIlHR-_!MG%OA>uzhQ8xuZ1Sxq@`c*<5~2avGhcZ9^v&BKM4L|7Ck-lT>HhISw@fW z0E-^M`x$w=yu&DFJ5JEJKq{hkIW-ySb7A%JByxK z9z9+==X&&bap64{zlr@V9(k|*@hthS&XVs#9zEWC`QimP$@heNs!EL{- z>ft6NeudG&-BSh^{rgNj>@~Q=gW&BRJ>K=gFFg1#kN#5khFz!qMt`}%MgIwd*BG33 zdiCFJ={alU8!SD7ukz^emUpiQ_s$y+So(|1Jns!lzu?C`dc1ZD@3HuEn9)rHA)Bxc$P?BlsI0 zJzhVY^59-O&szG$9!>6!d~7>&dg|=;y6ikVJ-F9DXR_c!%zaq;*=tX!!EL{l8{D>M zqQN;1dhMB48B$ht^)lEwaVQ(uo-`bECY!bN_MN58lK+3S(_ z;s-qP?0;69d|&j)d+|dCx91PXJ$k(QPk8ir@iQKI>YriqJ?oM8;>z4lxAV<0xcIHq z=*cs<)VttCmVAwoA85%7KEjf3G4iFByx?ODZrfRI>5+Bv^_CvNg}++LHOu5X*^(E$ zCQH6s49@oAZC_6rT=dI&aF3;5@BqvaHAhayNCMU;~spB2j6R+BBZ<*Z!kA&Y+RD!nOl9o zG;V-AvlqO^+DglNpoQZZ zZ@o>laN+T(vG6@ceujn1{i&#hw;TCc7Jk6s3oZPR!CNf+h{59)o;3Js3qN7-wHAKX z;9D#lKSJxR&B6-}zSF|xciue~KFrAPv+#0*w_7;g_t4t`3!h=|Ll!>E;72UH#o$Q` zUv2Oc7B2VuPFc9zzdLK;JB=QNxaTJEw#VRk7T#{~LJL1&@FEKz=BmxyR}=k5jQlW5 z{)E9xE&Qy(%Pm})`(i;0KP3I0g&&cA#=?^ZpJCxA3@+H!)tlf_-ant$@c$b;=5Kj_TtUh6Ont~M z8{c7}nOv6#qWdOA6GJ{tHX1uzfnn@e`)%$NK3m+7-UqJ zn*0}97sP%MqO%8Q=usS@|Z@nAfZbh5wQgLy??H0iw7$dhxLV@wGXL7?!Pi(;;dE}Lori|g+(pKY8KbX^EH5u}dCxyRr`w6@O!g*D zKhEhkIwzd^M{v6J!=p6OZwJXaoO1Bq_wsLR{^3+~w>jVKp7VVoURQX3iSO78zZ>5j zF2Q^H4)74TlG_91gZLM`J{Z?r5agtIrvQA#ct=;|1yi-)jyj5WbYUU6mES&z_iK;g zS`hDPsYBh@b)>c(j@|pr={H||XxfhEmrmz=SouBy0?_e8VoX6e0E^k3FCFKo*KMQ;f z!*hCor-!+uWKkdHk!xOR2jad|>sLsYDoi^8b)WiT;m4E_ylM<5g$?MW<%4eZ1h^6Us?=cWht7-gf)%P~u;L=; zqT$QcMRVeKhi^Rh(0vr|^fPa7d6~z%;A+5-(J!Z++$`Xz*%<_vNBl5iqk=K$%TX0E z?4w@^FYWeV-t?h)?m5Quis*n~qH$Cx!Rstf6#BH?u-~?ud86N0%lyOeiTJ!DkMHB1 zUq;$eyxPB%wk(I=TA`P={iSxP?q|Qx_ESRpR{8hQR@!Oj%e+|TC13F`Wu6Vsxjy+z z^Nn{q`~A8bTHy=4?>n|N5rfWfPqnUA1x}Vcv3)>Swy-{=uIXReKp(UG^fPVA*ncMd zPmE8VV?<2&o%rF7=iPS0ck=0L`aR=ov zdfSNR6hS*-eqsaLeN@Ls-`(VFisN>Lw?FGJoFamiAdhp)p6aswG4|u=zrJJIV4Uy& zqYaW9@-JzFKSg_C8)QAjVBU%2fMd=njL{{hnu{if~t9Y5Nhe@+m( zmZPsrrngTEs^A0d=ojqv7e)Jzq5Uhg-zZ{_@6CS|ZM6<$o$#sqEsOWG`TWcWTjlB>* ze(QbYo9wrnIvHz6QMXak&$EBgen8t}8)RE#J#hpuaVx?TI2Zz1@>4!E2xA?3T7_8bN0O^LCS@8W~gvW)4D76(%?=!+iU zxa2R0K~F8lOw54RFc0c+3d0W^1TW7Zlvnygwpl5=?o&}#2mD7XP5EQjwkAqcU`^|N zO81-Of1*B)H&NKA;|}%0w)&@hOF8jx^6m6LN&D>x_|~y6VC-l=chMKDgl-4vqwqI5 z;@FRH-oQTk)3oCt)9TpiyZboaZT_To+#7kETlS>qn-2=}nK<~#zyr$u2=gCu5&fc9 zFqH!L9{D|epN$_5V$KuK^{3jv=eYkXAw7@j=%$|LoT(^?@hea?yd7M!jF~88N?;f3 zl;vLX9QYHi1&%ho^8HZ42l;SLFoAD5B;0o0clUkyDpfxKbC5c zuD)~2Ue^7F`s4O#gB*1$;%LrUwlR!60CO)P?jD zyP!MIsQ;@s&tZ`gYf$u;Lcmu3fUcBQ{aek`Gz_;x5W22oT6aGhTPz~@t9ZWd`=sZ!@AP#n-LhS8yNPwxnQ!#N^wVAG zflb57U6RC{^{bdO7GrJ~#PLy&bz+aH!=y^+fb($K%c(;k;^v`w`9jZf63CZ89^)w5 zHP5cBH!VgkUNHSxyUC6e}1+x z@LPuA3#Ly(x88%NatFA|{IKyTc!Br#E*jT{GQGDFe8U$F8~aVzzZ`bQ!80cOiN3t} zVbOE+v*6W&?l{Js4z&GMC^P-N0%O|)>GWnNSB+U24khqg&sw%?racPVsEhfp925l4 zg?r9x#5hkN7p2Ts{)oCJ2EF}uyn{A?wo`)k){OpD^B04=Qu?oR%U;p(@i@xhPhT?@ zoF-Xim`8us7j#QrkE zk@$w`sfTGtB5e}$gs$@7^((0xKI%&Mkw5-v-2;%e?cMCU`|$dibeUU+SZ`y@jAMLi zMLAcM2UB0dIJK(Kjgt=8j6U}y`n-tiFU-LZLk`9ga{H1WdK>zRDEt}6xJbWt&%l7M7`~8RDl>ui<9`@Pf*`JC0xn+NM-u#7Q9@g8se_~(I7yWV_?qx(#ZjA4l z`z&$H{gRb_-G1x(V?Ht{p6Ixl_2Y7Z{T^I(G7o;%uPQop9rWG(0_qw4+wdg5c@>3T zjy)Z?ce4XBZQ$GLr{(&2;{H`#uApZP!+8#Ma{l56&lCGD^8K+6FlQc_1aDY7_>lG^ zhBRMyA^iV!l{gN2$DurLj&?a)kD@Ikp`!!y6!eQ1X6Bt^eTk!(?{iEI4+JL@Y`h9w zUq>NVnG>uCf`>Qi;8BF@Ro?*aQ5@@qbq>ePo+>hreApO!$)U}0w*zG=$y2wo4^=_( zVRhSe7y3TjnqB)oeA@DS$(mNwZ^v~iv!?7AuTn|O+c0N z#sh=zB~5!THHPDZaOzVg*&p9kcyBxIy#!8yteJvXvsU4LQ9ah5anw<< zGk6Z|m-%d4cU2ba6-?-RCngp##_CvP-{FnN9pIf~I>gvFFm7cyB^jf-Y*^QK_Rnsd z5?5%`>=QZ=Zz9{-H+0TH+n^_k*r`HUDq(j?p}Li}&%pRM26JO_?6VG8e=D89@MDO3 z>TgS>_kyM2;C6h!ZBiy-K?ARp%Il~2OvB>b}h*Uo$$?G*k@VjW73R;K9~8%mrR&Y-Updt|Jj+%cr3?JR@XE%C=R%+D+TOP$xB*7-BYP#?=gouV%Q z-a6`|Ua!vQvdF&+`v)U7ICm?dPvEC|v$khn$~iNALHzl}XxosDwU?~fzu0Z_;*;Qs z^cc;3Y2qPfV&Mtodlc z8VNC4!T9BvSB?C3pwDN2iuF^Z-P|YZ{Fb3RcgFoP*wTMDINvs7+|la*g|SiEn)}_u z7j{06G0p*3T=HDHjCpb%zW!W#Z#(+^i_p(^z;6oc6mku7%(K&TE#mzq%{v(TIQPB| z`J$f$=Qr-<`-2tcw*_+4-n#?qky|vlNRM*#+s%A=uOE0n z{QZw^`ez*efQ7$cP^roV^XE6#^W|fQugGR-i15m-20%;HK*lB9U>$sqSy3UC# zXpYTwhB|W_MmUQbn-?!7Q`Edzi+f~BH?6V0arS+U4bI$HQ?pYQiiDhnvHCgCT8Gzs z=P*g^p4ja9@|;{oe#!jCmW8kgNxMol!f`KyKPjV$SqeE5xs+hDbAN1hGi7LcCdW|a z%~w0lG}t`5vB~)>l3F#-Y+hKqxaC^#df}zv`6!sC`4Ydt3TjyFmInD`?1ZlKlzR;m zz0J^j&+PkX$C8Czn*^U|k7+w7f4&{idSByw@^8)7VwPR{mFRi1o0Y1YJ-=btm5$4n zbshMqTyb^Xyaf%7f2Gs{cobp^#AUIj`q@Ssf_Xxu#^F2B&ivTCMhBmHbmlIYe-HfW zvSt}IYUtbsec0SI`+-Irp@@2`n>$A%3?5QgX?=A|X3lI}td%v*!+YJ@QSu_Yn@*Qk zzdAp2_TnZK@ceR%UGrx*&1z&;lcajwIGh)&pEY}aqp2)h&(sS`&@^ko;${Dq1}1p>#zE6w9)T>5Gc#;a z{?lpG2H!0itzg7ra`f@|>xT&lw+7d~cK>6;wp~%V{_+h&D>n}LJkl7lqx(A#X`fIa zDdsuD=!jC$C*(O1BCCx&*0Gd7 zC)6wHe{96I&raAlY||Ch>xXZ+a@N+t4-W}%8M^s$f8{Tay!smR7xJo!o?{m16*nM~ zekP=b&6jT(`tXpggQ?O#>Buj^gyu~%Rjv<1)z;!Y$@M!4fR?Zcx=?Rk>QP3Z@Q{_ed&g4VjjDuZu#uy5p`Rye0X^H(JLMq z=C5HPUVkIJdBm2_-ge}dQ$3!Jbdewj|_YCiaRM>1BllItjq^h8#$^b zP*@*_3MP4uv*OhDIZNA(qQm90b65}94)LFm%liciF{#E)fm>m6hD?mjAagP`bBv^H z6LXEOg|4nnp1jU>c$2h4igdLxwEsIfw(@kQrU7{jD8R9oV@vmo!1yd4aosL(EPWwk zNONFe&rLWpuEjC&eI^Ut2LcNlT%Hk*;+)&<_@g|&cc3@jC*kM|25)l>cKbG9iw&;$ zkQFxFpJ2Znf7H{SPqdTcWFwA=uVw+UNt@q;W1VkL4QI;t1B0(M_-gkuZ)9uvB0ltm zO}Ag{JMc$6!3&9+_JsWz{Aqg(uGl^f*I$S zbM6Le|9%|jwXQh7TzT{2Foir@SDat2{C}PEs~C1l%y_cI!%AJ_7E zg<7+ibD?=l<~Gl+)vG+>qFDA^n}Hk6WgpXYXZnz(pW8UI*}dSBjuCUu4RIMr&zcux z;U5FhnOXQRSvH+ag7~b?lQUyf6a>*%+-r>S41mp1|QrM z5RxG;{O?{^9J{}^c>z{}jRv4(70KoxLe4a>xn&60U|K^Xy>64cWmwZPMo;H5UBe6$ z#E0gtQ@D|FAJ=wT?X1OyN)9A%SVzX@p2zJ*Lq3Uw&G<>E*E%!(IDeWYdLG+ahNZ1( zVPj*1YpJ$9L%N10;5LkYrhW89KZkpCnaw=vuK13q7w5c%n~j&d@W=3n49<589dpc` zJ3hMaI$nZvGi<9NkmGg{_FjCL!KtUj7195edhkIWe1pMRF6xnOi@`;|;E#Ir3>Fak zw=6w}%r%Y++(eJyJ<%_5v+WdaRk26rMXQax=n?#(EPCGX;6vQ3+<(m)L-b>cq_-Rk zKVZ_xJ64jf$oDkzf{VPod&P2j{nKpZiF@r??ZF3`Jh>CDE?d5znfnv>%1`v*Ui~vX z_)w4jSstA4vBO%<1O!MOOMR!1zB#Zy0 zy$IKs*f026BX8@;;Tjs7=#lm>oL{0x@SaBA)+6f)(KEyNq1?!e9>IkpjC#EOTHlu%-d#L{vjwD;Z zm)ppzU$}&9`Dk9Jes4TCd+^IW`95fH@&5sHZI!{r|AGrQ5cBo={|QUa9$e=p?-+_6 z!P_l)(f@+MMPBd&24}t{u4?^nky$^}{wqEBK!bC9^x|_3PCfjwRkjyA_-6&g{tXX4 z!h;KE(8u(fb-RtPH8}J2)=QfQ_twi!gJA3ANc*Z{l_i_e#>*bK8Cu!u9mL9=R z8Ju=r%`^8Mh|6zVyfDjyd*vsa`wo=%azpI#;H4h@Z+P&L9( z{Di?r7+m}#^1`7bxX2$d^0af5Ctu-kA?~$P>AQ*UyuynMH;ULwm%CEF6EkN^b{Ff^a#GtqsKdb#XWkwep_X5 zdwubiN6#2f+@AH|-u^Am+&85C-u|u7;9|e@^F;<1`vo89(c`W6QcDkRO6slL(j)jn zOMa)3Z?MbA!4zsNsj;Ud4s;LNwgH9`M- z#)CT^T))+bbIK3$;7%X+#Ks@;;Cv87HZOvy%K|Ac8r!oei^1>fM&s7d?XaG`OwDvGnjoA8tb|e6_(xSo%f2)WSu++~9V; zHJ1LU(I2sJ(Q~(@U*w|}F7gi=ocZFhvCP)y!O1rw+fEPejgvzL7eCjS_HxAF;%C9% z@aP#V%CXPmV1|wMc=h-5;Nx8p{V$#|*V_Qd2i?Q-{`CQ;$WCKVp1De#p)9{An`xR7 zTz95(GSoM9=IDU-ZtzL0A4eQt3);F&WZ-yftV0 zkC*MdnR3=({tLh4x_jQ{;`-iB&)b`J>@dZaEBP<(?^_q`^0V8wM0C1^)q3}7IG)Cp zJDpo;=V8|zPZgtGiYMpOb3Co})Im_26;wS{fjYPBpLaQUe}eBJcC2*Y|B2(BlVtbs zuA|^qssp#u89Rg}~>e@IDOl z!PktwVfKe5-zUDX=CB`m=REM;)4bl$bN}gDm2+|~^vA!j<{QZ`?KvHP=hwj0$&+|w zUh`^9Tzxp{YdamzQI7=M2Osq6RG;we-9op@&-?D~5Ma{Q8+hG3=gLpT_EOaa_~fU) zbH}tnUdPt#?(|C~GJe+>>`(0&oBy599J;r*MdtSNjpz0Q`y1ahTbL;ixOT3^?`7GLquwN`og2p7AxGG{Nft?&CW0bP6A8 zsOQ@OwRl!XKZ|1a3uZRNmb%Yo5N_aC=`s(o@T_)8lg>eGZYahnqzgCt28fm_p{_kGfp-)wlu4&^~Vmcu4`&iSJy9? zHxI9=sH^cI`o^nooO0V$cz_2_Cta<@8)xA=g?PI})c;ra4ivDK?MMm&<5t=k0{T2p z|J(Ubwz-I`DNBtg`+TaB^wK^rH@MxOFSPPCYCbj=jxaj^()655Fe|ZB@{#-<0nA>^ zl0DZ^a_kjd+ZEV_>{Nr<jarrcm^{YUAi$pNDE&AF3O_4$)hCHg&D zaH(A5zSnyUoEPA{+a3Lh=Bqdy_m6*t@2_I6h4*b;ZWg5;Kg{>U6^1wQJ z-D@c0-uKgGwBzYfcyxXk_{e^uQip*@@h+}95K5_sg5cp8*eBlC85f-pO5l#psOSW6 zn4zrgC~NvpHJ{D;| zxb3PQddPjC`NqIA!SrGu$`PTiI5-D|Uj_BCCWiDy(8U-`fj3Q|{+9w5o`D$p5bz3~ zY{$A_`*Y%G=r_h9T@>65b5_L zB{1mTN_!^3x6%HgR2%wF>3?W@JuvWMOpDfq;EVX-Xcuj(A2?XZ)gWzRjE8$c^CaF7 zN=0)ly}+1H-Mu00^RD#LpVUi#QaA0{o64RSdBezsLpiqpsOH2tzil&CV(4cfqubMX z@(aOtQS`ekC(Fq6IC_H zqKsX{a6Z}*Y#Z(!yO@?(JJzc#E6d5e>(KrKxE4HgE8}NW@X&=7AugYTf44g>1$Ju= zFmM{g?h7W!VKZ<@bz=MF-4a7oPCj(@*^XEV!C&$3RVKo^P5JZ3qnz+vAL1+isWMR# zn3U@1q4qu+P@}f@#n^T&{0n`Uq>T&q&l^kb$AQ>K^D)k2e!;QBxmE4G{|mv?xNFtZ z&gKcJ_|52V>QpLPS6Pu9TR1NI74VJDMBAZHCm{cygi-^bN1+|4iTL&Y`d)qF7~35c zPB5O|2iH)^bvGv79ZVh(^ofSc2An0sigXLlIc> zAUL*A{}>D7eNcZJK7`GG4}4=l^%?lb?qjj8S&KRBy7KiCQojN32K|8Xq$0gCcUQb8 zV(K21NcZ+vL^019{79vn2kIsUU+zG;V(>fW00);N_UjMDx7PPX9RN$;2u{$8;P+|Z zpwaGF$Wu>mkt}t_>YYWrjGZ8-LU5v zY!`Xtzv#uu;44CV-vQnt#_5Uy@DI2gqxY$V{}Q#A?Tzv!rhPu|@_THEemQ3sIOCi-C_m~SH#s78@IUW?q5qAP{B9!p zTHl&lw08&Ru{&`O&8INb`45UMccCqdJ@CnSb2s6{Ik)WJ^c;?Uh%0afUJF~np%l8h z)7GR*)X_NSH9=Vbimj6M5(_7PEVo^ftG9-Jvjw7GV~A$4i47tAAVTUya? z9M^5K=)5*rT;*G&Zcq_$9+fc`ljuVkJB*Jw_?a#Me-z{VZnT3AZ+*l6?cjc4JVd|T zeb+m>um z_YJfKTw1{#v=fy10rWExAMLr$xRTx&cQHPfpf4JqbJ^k&jHTmq1};uwUe<9>Fu`_I zlA~_zK)W2zaphPV_cOsohkmsK{zBXD!+tG@w$TnAn&@CRR)Q*T?1!)PMqkdd9j81rl|v^(@cy6hF?SBHGq#*QIhiD})o-n?d9roDj&tr7Ls z0DpEsZad<72iJob_c(4ng}sA&tx52cMLFIgCfkM;jg6~rCtoOmp8`3%X&-G7-^TJ? zds%+=U9In2qx+LOwDBm~LnXN22IKxT?e*4G2mIk9S1fdGf&Gs9OrJr$Rar^j|ESo1 z+1YWioAAwo%TTA_1EVk7da1oEBl{C6A7f?tohtFcf2PL_gAT7<37&tsYFFLYZp8W) z+__EFny0X567xXhNgd0-;_~2!Rq?1g_>^+ecBS2(0nZZkMt#F{3@Oa#=zj-ec{}Rf zYfCbj*5#xg#=@IO%j?wnfrn@N9B__#tr&;77O2BmL>@`6uK2IhWij+|EIT+;cbDX= zrowq)0L!HGqHe;MZ`#xEM^E%Xnw;Xz&TNlvnOUDg#Mlp^Tqt4M@An%Sf zA;d!T%LTi*cG7kKhhmJcWAuE7annt8Thoa8UWn_oi*53&XeZgmn&^?V9&4gU(_`qv z2-3y-f>RNF@oYy$7!Rz!Lg1WFM8QwT7+SufU{}Yx7msC|Wx5jhTKrz}Ztt<*guH9> zMF)?;f31l7Fxr;*kN)8C4!>_rtd~0ueb1z!kH%p<4Y93wd@jB&0cUD#fWkKmEdHy!@q+T5$t`L}c#uT91^;vKM;K3M|WIs)BxbI$S(@}QmZQ-}$~PViKE?;z;r zm|vUIXK@nuIo!EJr>#ApZ&09g-6L2pavTmn^w+yM7PDPrjE*o5rXiO)eK-U%^rP4| z7qnUpXf874j&uy`c=EhkjGfrOVi--3ptI{>=nEZ>Y!I zjW)QlE_YtTrr@rC%!x~|MnoSw-NC%g`On-` za90}l_}so^nP>g{d!!++S;+YOQp|lF9CM66rmwm4vU-&JC&>TZz<}Y5u|=@)DC(gW zZTKp*;lZOP>9}S7Vh`o+ft;ShVZGtn>eelNvIEyNpEdd%+J9+xa$?GNAv(*o-;~Q+ z)(`$Bn0Wn1=`laRHTE?M{Xf>*y085<^E5S}_JMr^@Q1uPrZ`2RA9Q?x^%i0(3hWK|KDMbk zg{WF^1o$~ZKeZ2$yIAx;1xMr_=ykwovw3jG2wJG-q@@Rz* zS>_Toa8xV&$Na?yvd2B|RP2TuQ}s99$iC()(J42kRvdj1vVpI}Zh()cbWc5pd#Ln{ zgZmGk#y3fYu^nx?E8oOcRHXv-D-K8f0e!!YzHbM2bL`7iDSrcTe+E~;eT~F0?tM+y z!3N3)!Q~wL2F_>ln##yOiZVyPhWkG7F~8Rk3r|nv%%V)r8XxWmM@OY#c$ei~yh3Egdd z(LW%*c|YxG#AsbU?}uRnK`%OwQuYhXJ=*3-%GUmrPIXc*vi4)$d zg570H(4IG;?`T7;sFq9nv>{H~(1zPo;aKJqy@9_Cxct{gVOt&IQvCK!$kA{0xbOH) z{S5-d_cx{|iudI#YQx&8_?etVNpcnM%~|B2U4~FziM!6dm*@7!dhJMCdEcW%%e%k# zI9TTk&apvwN6{x`@R-5LA4;EKZdOL#d8VVEB@OuGhs*KB@J|xIb>Nx1z0q)w6w8jj zdsG|BLoU!LxP)15)+grf5!R#A+pSk}`9m+B?{M$mv2Oe0w;jsU=j!crWE|?npNDzJ zsR`ua{)agFYK&1QC$rC{Zp00BM>&2&_kPS9%3v$gw;%>tKMMD0cCeqsynYAjCyG8Y z3f_0;gW|EYH;vzH9AA-JU*XRBS}x^j8Q6#Ap-;%8s?f*PpW1#XKdd+A!CoT{culpyi%z^&v_Nk|un zygNQg`=x*AZ_2Bd&-7_$Y=v)0_`z>o7rsD`r!T_iwmkjo?HAho=%+IG+TD3$eA6uz zdLGYjzHGXn!qM~Y;OQvFLCnKa&Ijqtc&z)PfGVTC{HD)0l{2<;u8uVLtt0x4n-aw% z)FL0!^PW3xcpP;ib$rHryN5cK!}jMP!@A*lyOD3hxF~(uv#^=hxUN38?1#JR(QakV z(-(E&-lO&n$9S_lhPvQdMDr5AhGQ{&>8 zJEDJhoA)E)SmTbseI0(MBJOv_X`RR~j(IHd9u>#BeLL>$v>_JS*iRg1y{oZN*z2xy zf~R9xR|H{C9P2wbU9nClZJ9B9ZrP9Adv^XCD~f9{hk8F9VO}UlAJ`X(q6`XUh{As6 z*NG2tag^sp_>tE-@Y^GJ!BOrZy4?H?iod^sLx1=2sqQ@qmizcr+-psBAA3+=?>2ld z_wb`$mm+`1*o<;+h~pj`baXb4Z>F z#^9RJZPTlr`)4)IckoP9Cv_{@g5Jm>`b$cb476xUfW)2W}eWIi)nvT*JKsEW-5eX+;xPm;fHcFaMFd9&xkThOZ2!H1Qx z`LuU&m~0JHCcrl#3-bNN771o>sSY@LP$^-K658tHafjQNfC z!(R)Q+%wCl{RH_1a~mxACeTXNH^T>DF+RVvuEy#X+KDP(GQZ(ka8v6uFiSsxnpr&8 z!4ZgeA81^>;3|+g-P1hFsaw#n^h%{BFuoh0GREKqDR86I=v9s2k7~d*JaX3DiCJubI+lk~peNUaW4QU1niE`^o4CDt-~-jaDPc{G$a%!V^GCH&mE z3+{Kht0_0Bsc8wS42^CU3T0X(yJsB;$og96ilI$csOj)Bs#$mBHB+ZYD8jr9j$wjfi&~1_a>*V z5xsI_CmXw)s*7}JuS&8jTC)7tK5m=2o^+)*4KB7iNJgMUK37CzQ%+XdnEJvS6o zZp`1*qjGcJmhShSXZM}wojq{gnZNqs+?!sV_Hgc$SEoFj8-8`d!?{DCmWym|JGnPy z1LyVzUj(ULI&D05rIfr=wwl6W*9VZhN&BFxm$TmgSkAV9TL-I+PU`2z0YNy_dh(?Y z@ErRd>$B~`%JqdCdRK1jwdsQJ=AK&$!Vl+f?NRwi-lN_9r;z*WZ@l`NR70qs=3@xi zgU^?NYQ{hw7Czi~gNhrmfd&)*mIIUblk;Hrd39E~(Z9*3`Kg5;+CKrA$qDu0Jqf+# zxjQ`mfLWlyB5r*}AM3fTpmKfwh8|TL^EP$&Pxq*}b#v~tU!JGbAKIK7&Ie(0=$Cxv z{6(Wn`_jw9U9-uz(LdppmksN9CZsm`7*zMF%t9K_{dHYFtH%&lEBy{R<<$Gk>bmtY?)5Ck3IqvEm zj2m#3F=uZ#1Lz88f7KO^byS!5T;O~M;{^8HbRUNOU*oSUJ?nu}K5D8!+SG1?w-{Xa zTfqJ$i=LOV;J?m-zm)~=j{Lf^lkaSFg@y*x`%u_;XBItk zvfzud;P)H-Q9hWDZMD18A34(XWpL?dA2;%aCKPpFi!}d`MgQ|z@SkPDk7mJ7X2Czm zf)}7~>&nlUWWfh#!AEAnZ^?qs&Vpy-FJ6;H{?RP>-(|t~XTg7(1wWbve=iH(-Hf{? zJTkjWvf#tB;6dPwD?ERux3xx7#Nc}jF717$!G%{ukE2L)e-`~Kvfx{?;7?}36It*d zXTg7w1wWMq$Nj!8X`356wOp&ZZ{6Xoyjpi{S?ex7 zT}tbb8Jg*arSoga#H`=Z-mkN1@*3gW-m7PnOp?x`1$oQt}^HSU*6sa zzN+d<8{YTc01*%)1c*S*y#W-FQiKqaN+&k~1pieEvD#`UH~%n5AR!45(V81zEF)GE zNrfUU7jU3xuI?!?2*!s>eqw|#lRoijO4bYYm-wp~YSF!hfp8Y3T95^%cy}$39 z%P*X>pR@MbYp=cb+WYKt&R&R@V|Qh~q*OzDx$UKK&sM&CReArSla|A5aosNx*Tf8m z+Ggw)ZWpr3-8z=t=Nb39&G;0rrluSM+XAr;VLv}))%1?qRonu5Wz(vLMg(PA#!aF7 zt53C=wIP$83q;T*7mF0~LZ{2PLS!%2V3TsaF*$Frv1o@a#ErzbX)m|yb_QYAb&boL zFSlp4$x>6f<^e;?8tP>Z(TM#!NMEvRwP#0Z-VF|H6h2@D%vXkM14U@=TBh=gn)5%~ z$Qr@R^x{pqsEb~A=>NtO(aUfLU9NXZ*A)|#mh)wH9XGjzYmalAps-tbt}FhG^ICd0SBe#P>daxNw@*jSSxV6qmgiwzZs0cQ6!udr5EMI+=N zN;TAa-FMZpdRrPAY)K9JMwu;>n~z(*T9IzIbzMH_P$le2Z!)i2URPaJ(O8Xs<@ya* zIWHD}8P@#x4X+afJWTE?u&Q3uFmR=+uBKuY0A1Abrt*r)ruw=y*x4Rg`>D*;HC5Q| zy_`JtKJGe)URZ#+=}=yV3}s>K{fp)C7@pp2z5g3f@4T|sxJSKj&eisu2e&3b`jG

B5#|s4v0Qtq(~E6lvKI2|IjPaU3;&}hQ|2M_v4!5`~H(~i?TiliF@EjjLQv@#UaFK`q z6qL{3Vh?|ZmkBYdAxGUG;M+G0Lx04<|XDpw0JbWB}M(~mHUl4enX+r(K z+ZW!+*>3q~*>wabr^B-??zKa_E2w|uGg0uLB=|^tuHZ9C(BC2W(Ei(Zg`9_k;!jHK0SLXzNgCWuXPa0+tq@ODAJ1p+xapPi{ z#hpA3zgO^)`iu$uM!~;D;L`-|_LrkPpBDI=mfp#8-uly%7I*SE{FLA??PQW!P}cg9 z<=!uF`)Y$OeUHFDBjhBk&sqp2cS#__1DiS)~8>n!qLf{UZzs>1BJpCh(d4 zT=4vf3*z{ZewI1a|JMpUU*PQmpDplCi#t8L@pY%got_<@5PW329~5{*@PAX_vc9J* z?#fNres{*=u3U$o6MSU*W?Q4D9tuRc_gmcY&$0GXZE?rn;c{PcS+6~UzdhBZl-W+` zZLeB^-)*V4OgkBJe0r__ z8E$dM$KhEPXMLr9>I7aSAO;;DQ?OSH) zo%{~JU+|H7s1vws-*$mp)oOuW5cpgn|0@EQ`Z*-<&k6c-0+;o24~|^B?6viB`+&Q8 zIefTXn5Euiy|OJ%KDH=by4yG0d%u}4=&8^1)*j|s+?DI_s86|WpK;0~>nryGm-_7V zl-q0lz;;i$4&N!tm3rPUaM>=e3H(ol{@=8?)AJNJ{#xAC*Wo7xAF1beJbc`~%;!9O z94_}amwZmyn|#VsD&%~};%qO8zc9uSQP1-Pz1t_6_S5(98Xl7YTf?pubh% zCw=&zx42ht7cB18o4c8zex%-J*qaUFw~2BW`QR}hyu}Ak2>f=zzsKTE{#rYZykv1F zzr%Y4A8EIRwi8nR&kO!hij#CDGcLVi(1T%W-gqz@>fOD{xt_ z1|R$hAN&P@OFirr_+l-g`R{_jzaa3qU5xYg>&+JT>Mdb$)^~~EvtQt{UatsT%5zlU zO9h`oyNKrO`HXEB>}8>Uu3a2H-{RhOsrB&L?(ERR$Ki1geY>UKc7|GP7e<65qzY5zUATL)>D!mJ`O+W!{?OXBm4Uq zi+lY*rd^z3y*?+}H(%fpf!A5w)pwDtZ?nZ+eH|Vbe5?qX+fKnp`hgcL?zQJhVIu_P z{GyPjOyF`p-(qpD8x#t9+r0hzyt_;H+Y`5^=pLJnd+<{>-Rr?)D2KnJ=FrdIy{A)X zuRH$xt=+nO4tMXNJmH}~W!Fa%9=!iOl%Oft@p11Lggv->zaZa(yY~y+x{KrEp0~UB zsSbC~+Yfp8xaZqpJHK=E?)mor#eVVi`d$6$jrzzfTyL6Q_&>HqYZz*!%B`6jCFB37 zJ$ocE;*1aGmA2{C4>F-6#H~u!o^dTJz|?I1OjyX`7=T z|L^9%2|38qHgkXe-mp2P-16t-cUTcln17}N?D0_8oVa+L?y}48>ahqHcrM3m(mruL z|5qxk{~!3z<#R`lq3(QuN~srZeu?qiOS{Zs-umyg`S0~8*2(YqR^a4v?cZPr*|;r` zdb|REF28GkUiOv^NM%}QH^pY)vRD>zUc}GkCr^)v`udDn`k;>4`(2Z|wEkE7c-zmS>MAt?d&B;? ze@_A29=7w_#WsA8r*iCf_T#QdF&(?srmwZ>Je$t5>FaFzI-8zq(^GAFx=l~F>6tb? z)20h-x&V6y;5$u7+u1tiiWI*sbNdvUZ!>-5-DAFmZtYe^-p6hFahv|GO@G&>pS0;G zZTe}Oe%huRZMspVVjG5aP#&#^!xlem>0Y<#*KPVYHvJo${}{xZmToaBtY>3Tam+zu^z?o7J}$r5ulnKP*b^ z#y$nH>GMi~Xi}#K?8vEU>&&TcS;Z(Ww+0K36lC$uQH0sVH_jw>*0lz|<=8=1<^`Ao?o;x|^ zeiddv;)7aGy6ooz9Tk_9eaHHe3)rs{Ww9JMx*lB?zNsZ&?p>j{CmOCt?4AVNUzqxU zJsrOLO6=K3*>Vkiajr^nAF-FQw@3u%+}{Fq+oJUj{p)<#?;wf2mK5wf`Sg`Vv^nl^ z@UoDN`x&TV+(Qui@WReq8|eDu8fDx4XmsoQ>inE!WyygrW3R->D3$thYjo=RAu9j< z%7D@L&jKC01z(n*vBB4A$WWZbOE-3`Gfr#`MCF6AM6$1-s?R{ zoLmosJ_+C3dp^DImCKZ$!1wmAgMYa#zn=7H8|>+@?|Gb${yn}C2hYIQ;)mZytP$>& z>8(QypBp^`9^4zid+j6WGK{@=ym%t0@{eI35$q#dhUW-hNNvdI$Q`a$pZa~eY%XQ6 zdo;X`eNT?(aX(D%U6tK^?7iH=6KIPn>=kk1W|eyDkLhh}n{Oe{<#hMH)t%GF9MBnm zVD@ll|IbmGb`PLHH~Tz&1KZ|(#AOLS^=Q``#Aext*evuB-#~m8y|)Ce2Oqin*@_L= zzW{MsN-xA;<(`r+qK^ij`f697-lNRyGg0waNvdR!+NZzuFGPC{Ry}5aFSGCNMtsN4 zbRJ~o7*YkA7;IPDA<~p(4ZfMDZ>C@4_xz^czM}gr?Sc86&25-T-+S@iyso?;c#vP% zhu3J-Y2P0gZhh{Lramk2jk=frDd;f%QON=D8i{^+7~j03pR3O31@1i)U-Aa7PdrtU zs={7GO!tPkx6Hsi<1F-e4nCOnN;%PX+j1wU#@+Z7+11g_QML|N=*Ons4rBY}wclA3 z3}hBeij^F|eNy}68Q70?|DcY%N8ndX-^<3U+m~M7IdDC%(}zdh0L>-*%LcAVJL1?r zDt>K;8CO*I=){x`y^jK9JBNL=WAG(y^e1T7*2mQOR_q&(y*kQ%`P>a16YS}5411s?v6oFBX|U(X0L`Z~4eh3P!P`6@YfLdl^a8m;0_ zW4unqF&~2;JG^a3{4m<pzDMto>0iweH8kRL%DX9jG~;d0<27?FUMm zuN_%hJA7oR8a#DF>97NkuQPt_%A#tF0d2uC9l>#!Gh|@jh-*JxwC00gDqea`$HwFL z6jiB=sT+@v#h8NrRGE?5kRLz1`*Vn?gnisA{}9A}T$tZ2%i!4E*}6UhI!r8yJwE6_ zEEw(xs?CQpu8AN1*@*bz>gQBy&{yM!s~#QQ6}aPDhckllrz?LNOr3o6(0i?qW~5H0 z|M*_(hKy7w7(YDrt*g62f!E$Eh3>|5j)Y&q9)#b|NVPq;06NTg9I=_hlxj2 z;yq&STI|W&F(->ZUGeB(UAagnP&Urof z4X$=~a_^83e8%&j#eR!Zd7X4I=(1A#&+LoF@fhz9u%D31#-8fPLtXCre@s8neGS)h zvjeQ3)=lLfOR#smx+#MBZ6$mq&tK-AoxxIl-iC3aaAt}Vl=W* zZpW(^`&y4g-<8+=czn&v!jn zH&p(54EGjTR?L1`70wA@UXOm)fw|CZ*rnYg-5m2Wv6uRAw1=QC0ez{ZXTKo7PaghB z7j+wf&!D}t&b;=?!!PTxjx?0R*@gDIpwGr%6Z~u^{!Dxl)eZlXz4giH`5&OYV(^PD zPDw1yJ)o?fN3pLB)DO?*zrcCOL5xLCj_{)J7FCPAkac~XoCD(-%kIC=f6e-M*hU-5 zjQ!N6e+vJHdtLOW9u+qAVw!D@RhSNrZK!KD({h}{Gg|D0Kd?{XDD?j$*hido#C-wm z&GbcgW|6U;9R9;-BI>an#FzLn$2b94LeZz+4?cXt%E;vOol%oxM_$FSo4g5ja- z@$FkQ*81(ire1%r=|9-Ctta>CYDHa>j+Y&;h%3847x(KT?|s;3Q}ce>@_HKkeOce5 z@njmtv)#)^_5q>%4E<^^dphdI*tji#-(e^+tQW(OzF=)2nRyahrbJrq|l^ zTAN;P)9Y>eQJa3$rZ?F12Ah7&rXREECvEykn||7+pSI~|Z2B3S-eJ=_uvP?{OwdN- znPzQ(HXFNo;2icxThjH!HLX*u-6*~Ppt*;W?Z9)=*tkD>{_6Uh>+_~Ro7g^X{$ye% zWayX)A7Q?jLhK2~O!ye{MwTClZa7?WRRS>#1E(`bVUIA3iNC^q=`Vxhwv=E$Q#V#| zK94=HPH%?4U57meE5tSS*<3aHbSd_`J2F=FJQ5u9YBt8x9Q^GIj(YW@(1dR6Mfi(W z#4?yaKKfDLm8$GZ*w266Xsp}7W}KhqT%7k8A2%&P-~C7Jr{2iAv@FW8XS6EYiE@r+ ztDb$q>{myjtoc;pA0=yVxGMFY7*e)h%6d(49bgV?V3z ziDA|>M&DDUIm?*Y`8`i?-aY!j}rQI6l*{OlLJzj_n&izAEkSk=GuU>ck1dEq)97fz7JUb@6$aPYu-&_ z4RROmOZu+gHI8di@sUeE!s`7{4A^DtI|_5f7T9#o5cLbv{rhjzW#2$QVjtoj%KPoL z6wcWPFo&4!FvbR>48^!+{DHYYXTN427JJooSHKovD|!ycm{{RJxF8G+`St$Ea(&Cq zqj}FV8nLsEVSnXy!OV^r*OsskXbfvhyMC9ceOmIdxm_{L)p9Xc3uCU<27Yc%6+6DD zD1rDM1AER*XpCcyuv^e@Zbms`8?G$k_}h!JT>d!sw!^&1&9xR^NN-~uSf-TM>{Dm% z>njVQsaEhJkN)u-@ff%+K)Qc`uH@W+{>;T@BX7>%QIFXb81vu9oFIX{3VE)umt=x_ z6((OR3TK?36UKgedBHfQlfj|klh_-PdryYKbJk$*KJsa8MBI=-d}QLWP*(!`;Ebuw#MhE>^1Oxb;`fORwyTl|yH(Bf45!ufksz{;tN~ zNc@e$UpD?m<8KW9#^Nsrf7jq|oL=uqVm*oZwai%mjTPUTg3m4rS1>*e*IhHZ0)NGr zU+j10zAFWt_g1MMj#pzr(}($IUNX=z3TsN)GZglz&FaYBt5VsAa=U^D1Blb|iU4Q&*yT(QFx;WZpXmMPv?!$c&o<+dvACfoo@7x9iTLO@U9%nxtt5O{EPyc;X)1n*&2x z^Fg~2ye3u+E2;**5wg1TO&KM)maEfM6Yndk!hYG6pv|kgvWRKiJM^DdfwmH~yjD5y zD@A!tgNrIhtt`6!DRqGRaNnXPK$a`DUB=GNOZB4e0kn_vwc)3NsoqW4A9gABQEr<5 zP(^X+fxH`We{xSrDi8b2MkWqA5Uv{fkZGeo>56Sbe1I9ak6;WV*l2u4<{a)npOH#$ z@u~(#yE(Yy?%+vRZw4)&O;Q9mCx)7P9?3tU??CS9=iw5EOLeJ8>} z$Cs-fJ+9q_dv`mgy$)XCEv2dWo#t5s%jDQr_&Ll?L(!sGO67-NE#W@Uhv_@w3&L~8 ze5m$K99D9m5Bu$#`N;V04QL_-(sD{c@q7k7`*z>Kf>sv z#1m@DoIdOy&oQ$Y{hAp1xL&`Zd_1Ro;h!6Sn84=_@uKGBdLZ9ik!`@}# zIkAlk59Dtg+`&CXW7XKlbPJv-VqT_o`LCv(0+640zy1F!_OiVha-+|ymTN|a(O=02 zW#z{g2kt^u7T$JeQ6B6$dRxw%KFpg=;E(z6r^iji7VD0~XCU3l z_zLVReR_^PR?l~7e;mtOw2TwFqiFll3srvd!L@}S1jlS)IkEYOS%q?F8;nU9*@hT} zb}r5Gxu0fA?&uR05T=sOEieLK}Y%AG%t@wmpLT(d3(nWp0VGsGadvnbw@ zIY--Vv6_?EfpcK7VjKfm1(63z4&<%Cx)owC?8ZDtmc{kv+>G4D1aXgjM$nJ)GNP%U z!fx0PSvKpHSc4crxE8L${<`XXK{$?iTUFoy{az3{n*_g8YV@Y{SCuvYNHzTXB>13- zq0Ej5+O#q=&=pg`uD12z0{Tv2UsTiR1wtQBNoX^S|-kRl~W4QmogVc0CYS-G}(HbBAGnUVGn% zcOJ7z*Y;t08~hQ*RXz98Cxd)=rW@j#OaFXQ9Zt_~;aGCo>_Jce$8n+pHW5Zy zN%*B$G2$=aI-h~6)5D8K-Lipm_$8I0QClK{SK{aC*&`RaYa_Sp7T0>wpDV`e_dojW zGC5x5Hvw~VwHW$Z<;{rG0RLC4f^R3$u9Pi!0x>Q|W)@TyGX_)e?LNK#zj?02`bN-R zb5R!Si#E)DM3-yyOMT~g(#%7Q^iFrl(1iXqUvvNby1sv|z}N}8c8-TQ>i+a0`j5hT z*ng(Cbsn8v5B-ymoj+?ny|8~*caGOd^kK#M6`t!x?^Ik9cy7uPytcz@$V_=a7=)hH*i`Ute`Q>=y4lREDnF(x&aj_^HIzDnBWppx&EuZ%xg@I3Bal z_j~Wg8~|+}!1zF0(e=WdSRpn@#fsYwgqNz+%RTA*$QE_r1;oNJw(n!hT2F}21l>G> zdwf2Fmb!ZeYatVFck`Ap+Gm!*mki8X%-pB>N9la7YjDmpp8ZWfGZ`pzU|q!Yp%~`v z0o0-CS&oy4rHOg_Cg>=v;yYS{>fKpt>kjyn!+G-t^{)rB%wEhdT{&!XDXTd*^6Xj` zSl#3!7GuVI6zJLC4|-l*hnSnY&tQLd&ac$CnVerevoD>` z`iGC0eo}nI_!rt(oH+Xqu<+le_pOC)+#G+=FVTm^9RI@pbpD^BJ{&if(luY|PMOB57hp7!T1uGmt-mIxs#L@nn^m69jPZ^ zXgiiJ`xx@P4!qaSf1+4VmFukZ&AnKYG~@4>ZoZF`ZqoJZ>}$fDA2IKH;d8um8Lbc0 z`(JGP;hBwY>nhaiuYvWV%-A1cKk&~HtbG_;FuG!y@!y(j#e65{IwKS7lR$g1e6&ST zAOm@CP_sXP4}@KFu3-DMv1885lE>3}zMKTjI@lxIf_255bv9+z_dIs~)o0r(cZj+v z`Ga&B=Ujy=FrNnSJiebQe@9-8Xs9P_P2;Jb?#kBf32e zJ^7d5IiH++JwYCrqh!NownDy9Q&m2Be*{|$0^>Y17vn^bf=8|Sk0o%9o& z+f9P63n0BI|IQ3-|Nghn9ir)(!K|=cqr$C zC^vb#dC!jgSReAzI(rJwpdl;I8Iz6YZXWer@L`=Y8AmFVsmsv5{1=GD0{=k2uYG-$ z$JZZ9&yJw(Ll|Q!G^9UYJf6;Pg%7y;Hm8HDw^Rrn#PJSfzYcEv&vg*{OQVA<-0MZq z-my?tzYcnTlFq*ovIlgZF*ZRT$aZ4gsh`LLZ3p?#<}WJMfxL{RvU@G&FqnTNUP|{2M?0{rSZFxr&}LrAc6#gY()m|_ zJ~okK=D_=e6}aE7fG^=(xKf3=4$v8ZZANhK5`lfbV`X>qVfGKw@O=i3Z8t$y%>ACG zPyLREmNcX#ot~${Pw^h}Jo?=Icup0@T#(lj3Ns~)pPUC~WZl2M4euVR+-PAK{hD=g zWs{ckG5Tem$Ka3Y1L^ae9}M6f+c9sZ_f=>c8t`@h2syQX#PfLiaQbiZA|Ki>br9j& zA>vc@rFR`>drW~GSl^k-_ds%I;9m86>9Q|>?B?70URck!qj=YkW3IawCr|pC-nYzH z?8Oyu>V!Uqa?;LMKzH0iiqKh7f|bMHvr(XXX3r%_Wkp+Dw!BCa#WJMykH?W^BMBwZZiiW(9vx&T|m zbB~TV+Ui-3-E5z;i0K5H1lo!1$MdK?&pjVl9q3VCV0%VzKaJRV>z5;*d2VxHbp_&S z<&IT_Uk4wyE!VOrKV>J6xrhN&VcUr)F}!fO%RU3>W4h zcI{c%7X4Ts_3fjAJ(Q{(i}ZgWeIL@l$Mx%x{t)RZq>thKst4w$D*hGtXMmqY zdR{0M*?2`qANp!+A<8KS-Ca1oF%Pof_^&vQ!tof6592rl*T>>G498X+N8z{y$MHCR z4ad81T#92ojze&4!m%F5hjF|a$MFjwD~=O!+=%0iIF{o$3&;C#91FT!9FNR{43PUO zq$eVsi|gZY42{wH=lX5$Zj8$thrtf8zB%ujj=p=$TnB3-jY-@S^d?LkMA~NT0lYJZ zXV?k!p;GwJ-P(_uF}||t7Wi_;dmYq?+^<##R!8gktT}t? zk0ECSa=N_X8skqIfNLEwP8il}167FOinTVZ7k5v_nicOU3NZfv1>&mm{*}`Q6d4<9Rx+DdeFKz})VkNT!;Zk9lT3=9hVxpE_T_wMg zS__`r#j!rw)_6-1`rV4%j16tejOVDbWEJX`qh`l{w4ewZE9A%Vd_9f%9c2k$qssVv zs14s>;dw;Q%lOuaGUI!S+4L=KI&NLyHWivNhw=HiuFE-k41f4K^0p+NsYEs-t=Bx& zikHzI@o)c2Q9N+IAcA`b#`z8_bz3f<;h=3Q#+&u=HatVe{1SL>BkoPhUdMM8^et!M zzu&*_GCt;6l)+~z&~x}MHOKkK@EZ%~{2aC)8;dpZ{|I1=#PMuE`)xS9YCwJ`o5pCa1RX!%_HwB(8D1NlxUvFI3crbqS93d0bo1x#bA;Lp$jW z@}38>MpRD}K15;87tMr^n4?lNFz3+sBUh<8eb7JKs_j}lr$ap>y#J`W?V*a#sGg0L zw>{K~HVfeUjg5H=4umHzIKVX4z|rqjPn_S(eVEp5lKdb&dp7j{gD0a0W(5l8wDG;M zBPf?PhHGv7=I;%YX6(qsW3W5uU9n9VtM3lA8Uy1+{o~ei=`vJk4%;dWpT}ovu#45b zQ%!vO1Z)rURb56Hb6(m2b3HjO^g z1RZn!#kToVj32uH-z6z#r|X z_e45BF%I(;{N-Yu^S5~K0d()4#PKI8W5vtI(`8I^ZV-blF;Dn7Z0%a)!5{OGmNX}D zq+TL@@a;%XLY{Ea%;%EF()l6CNFVw4?7!&yF{~}n_XUBwe#`goI5)(Yh4I9+=V^Tp zgZ^pL9JenwFF7}zd9yFd`%C2Yt`Wcb?xkzQ*_r8lt`Bd;82Uw&-2fRY^u2<4_I(ZT zUdY?_8@%@bdte`l+;4Qc`&a3*A*h4?jtXmt3DCwFs~uzaAI_t0P4kLk=u5nBH9Uje zoa=B7QVieGmclwXuJQa)oOAssfboI#jbMDB&W}PS`XIh{&i4ajnN#NEq3?x5p^jO2 zR*AW6JLf~?s`Wkg!KPq*N4a|Rz2lTKYvZ^W+MD;@^mpO=R4Tq8-IIrBiqtjVE#x@q z^hGcWTkLcN+mL##41 zqhlxPTl&PKdft8lGB}>pA@j?;MaY}LyutBubCrWXN|zl+*}16mEUeXrVgKaAy0d*) zXX=>sRe$oI*BAG}y1pzUnXAeY@Y~)xz2vFWD9GjHrp#{q9|YTp9!}@~8IH-NW{mp~ zZOT5uv6%Z3J95$_A05}l@g@1X zN)_W>FOC`fwlsqGi^6!nh~Jk+Lsy7&^ zrjP3}2+woZYa8g`dvAPZz~=>3h=qN8CdLTZ#K}jasTAg90bG;*rycWhFLpQm_72F# zeBX|y-b1<%b4@OijRy9|& zFmA0NGsO76tiC?X$i0kag5abGGo!B!)aMKkoua>!`*J2!M*ft-Y0pO?elG%?=}^HrlTOL7%H>2G(RvL5Rgvk3i8)wNPor12qb_eSkP1}=d`dnal+~lO0IIa#JJV`&8uHiS51v0`fzoawI)kQ z!+wG@*5l^z8r_D~HOnfXI<3mdGiU4kixDPtXr{<4zlrRTV31=r8o;{#d%^I+-)xEy9u3HGjHkZI$Cso;r^2eUqEMg0^I= z-TH8U0{i|kC^lTmD)c|y$F0i1twGb7;?&ZbMntfN<<{uv-qyBlu75VxtZCBrE&PSeM`J?7`c*dQxF^S*uJ56E z;S+SMaSCJfi|jgtIC^XKa%}x(RILlup|a<}-tJmlR=)Vw#S88!xwXtj)d zTGN8SU>AFyh;>XhFg1*{iS~w$29Mb9_Yig5gn@R31TwVl`Zc;`L4OhHTErUD9g#L# z0oQNa-;d6XGjMG!VGc4i2>o7xAl=Py_;vLRa;}F18%rI=XLMg<%%0bb_zc123H(h{ zH}=7nm-%Eru>IX#Ha?|)2%6l)f7t7ORXyE}_FaGS--rsGW$P_tLWhCnSo}pE2Vy#R z1|BeBk0$}1YiV@sV@VTSYKU-s2L7zeQin)y>EYP~H&zl2zFR$aLW8;*JhzGuv_3f)lw~pw%vh*9npBYxVZRqwZ zzOrM;H!~Oi`d4KGVXH|=BGQoLo0&U?FlX@dzy8(jOf35KuWse>wxPfNRq3$X@qfv% zwZHzAilQt&VBs&uql=f#DA_t*_B=+;zBumm62=a;0kcbnDemjnVtMGjD;M;~%)_5or4(V_wjfkxLl$d#7x!wrkb6Gq7m|Kk zF!-eb`Y2dVz>6aKXXs}zfbuOSK=(5`{Nx0#sU3XL1wvP9FD~!2wAQvwd~=32FJ)-+(r*sl zF=*bi89PG@JBMu@{uO8sx_1G;sZd1JK6+%~#n=)r)rbaiBt!BeJBCq*$^@qo4UDRO zIl8-1Ldmc%=>Js|GB37@)iIEyP3mrOr!bU~ZNUc-&)b>I!qS$vNX%=l(tjZ{@lCvFf0v7e{*=CkH@`iVsGN;Eg``SAFoueDJM4_+R-UmPEga6zI zf71v5oe%y;AAAh@?d96nFDCgs&@)E#8QULUu|~JphflSo-)~J?&uNfny$^kx5B@bD z{7E1D8$S56KKOTi@O?h`KLDp577w=yfPVSoyykNH{5Kz*^PJ1k4~E~o9G>li=K_1`b!Qvbb_^Lm-*li`QVTH;NSMaU-H3U^TB`PgTLp455mw$y%ml!3e$60oL&q3a{8IQXl%oK6teczQ*!zus6O*Bd*%uL;ti7j(2Y^Td%+K!QTL```0z5Ks}Ge z=}8~@3~bVPS-tt-1wQyKKKN1}yw(T*st^8kAN*TB`1gJAfA+zD<%9p$2Y=rOzXDUM z%jpyEAYT@r?1Rtp!RPznjO}^3a=+w*uk*p5^uhTu>*e_Wy$^oK2T%Io=X~&?nU^p3 zY9Ac$6kJx$=|1=^K6tqg{#76RSs(mweDI(7;75J%-}&I@eej`}_gt>MuJyrZ_~4~J zc$p8r%m-iZgDX6on_i_RwJ5}dU)EStqqwYU&P<^A#)?&V?!o7NT##qj`RU7>8Y`yH zR1JJMWFKtQv>>2-Rdf0BW#xQ6H67QQr_aV?9z3Vde*o=6XE3!NaWb@|wm*JRhs8uhI|qOo1Q? zG7Vl`b9tPEdMUlU5f8!E*65rji&-!)$1;1>3WHGD{lc$Axuz{>28Lkys^!h)cv#Vh zr&r5Y)l@^`YOI^{uzVH&hj!Gmb&boLYZRDORGVy?74vFNcp6vLU>k@nT3LaG`&E{d z4?9ezDw@m2mf;p{eX;|K9TDH-4 z3_eD3_F>AA7cSE8vbr@*G{5>4%WKfN*^4Uh6mxA=c~iw&TbKnd%BLThR;+18UemqH ztCv3jAq|VBTJ#V0HQNj(Z5u{+-X`6-wc=nFCfB;K}mi z*d><6|OZvI$Fu9 zs+Ii}uc&LNtuT4ecUJk2L0Y4HR$0Cbk3Ml?Gf~k7#(+|8o^g9GH7#F%ahIt>zjDfl z1gn-;&xBkio3U05(5sr3Im79HAYE=ALTg)hmEgcpSF_Ao>KZ&Foym6uEVurl6z0?n z@vVZIDwfs2aWr1i!UOemGXcC&)8BzFy((*LylT09$~vG0nt~o-t!X(QhxbklQ9r;J zKy(8-q-mv>22%u2uI8FLn99ZZnlItqP~R}?Vw%S0CJ(2TtD8N19;k1qb*L2B)c+%HG1iIfEu===`Y&VgNqmx}_u~0J_s50k!O<+y?g%4 zn1OgHw*U8%J@eN06^ncMAN9dc`rzk$@C?YopO-(^t1pMU^$E&9-jL}3r}@xxy_!ES z|2uqe_x!|5-(cxk?gYb9|KIGxXOj=!>4U%EgZKF0uUVY(d`if3$cO%h`L+e-uYJBE_*^IWBn5uGz|RXjEbz<>lW_98Yi@nf$?xziOHchw5qu_i__*hC zVT(IH4(GZqe_lTBxi|5!rZE4-1b?ZY79ac(i+lC9$p>%u!4npzJko!1U6((voJos& z{pu+n{ux-GbbM|wr~3aKi+kmt>qGBiW_#s%M9{l;BU!*EAO5|9KCC4%|Gnlz&vjJ( zoc$a!N#$Y*yLNZ@a7#})Z?v>LV2?xn^XhGqz}dgzhD=Sdxa05eX@bABPZx{V$?2}$ z;o;-(#e$EN^InU4<*XLC^oLyU<#hv^PZ?L%6ufE{nv)S_5rABUgu;gf-NOa5HFwwt8Nw79F6!-rekE6)TEpM>QT_V97|Bp*Ip z2j-9b`96{RZSwHnV=rv>@OStVf{$$XPQgd|pM!#4zp!ulpAz_VCk&1*Rx#z2_>4?L zMEo;?zD(dV1m0|Mr+>T*p?{B9-09!palvP@;PZrsPmAT#?&0I`P9Hum2>d3&pX<8( zIXMe0|F=B+9i9|?q?}yu<&XNAX-@V3%~)UM&+$)K{+lfB^x*K#7H3Rs$-mQw&kH_$ z_W1DG@5ASy51-e3_#E}&bJB;;DIY#r_PIXwBkeZZ;?$4C;}-XhJ9{loz2zH~>;GR8 z{0ju$EATl2KPvD-fhR4_awVTr0+)Qw30(5Yv~O~;zD0unaDjhT;8_-@9wdFXz$JaN z#c78(3qCIhe6GM>5%}i>US@ANDQB_3V-}|#B;IaumKzoHI|U!vjxPv45IlZd+T*b@VQIyKk7q&(g#21gAc#jF!h!@!v~*laq3z6lSMxCF+pD@ zJ$X@aYx!y#jwr;9nAW(ue;UA6&oqi~L?W zv-m>rW$>^MKEnr(`rwOw@R$$Y;Dg6~@OB?O;e+q>!C$ku*RJ05!A}bO%SMIz|5HBv z-69nEyKf?y0kOXHkGLEMhg;m+Ue$trn#rpFe?s8yTT5Qp&u z3w`*^_2Dz$htEzyFZKC?pqKcxF-Cr`oY)*i|GaX>eCX?Z=$n1;TKk?K^%gTl>Hqf& z{L=zIDsV}E-UrXlF`3D~LhzX;aLNCEfmaIp%>u6$_#uHyKIa8qBj_`%(NLac0?!io z0|IXmxEvq%3w*hte?{OA3j9rrvwh{f{iMa&z7oG6=;ge~Ei!VRCh;kD@sagfA571PgvY5 zPrJpv^6c@Uf6<3N=|g|Yhu%GO@ye5FCud%H3N220+tj*tQ9&>9G9P@q5B{PL{-(uQ z?wvxPZ&{pnCGkSrsFYvI^Mnt+-Qr$7Bm})Z)uq2>6KwYzggh4nF57*0t|9XB&$jp_ zdbYTi|Gfg2{A+#qH~8>>LeO(4K5y&LZgF=%d!fB;VpJSK7}`i?iI@3=92#e#9i$ zz6}DOYjN_CcvR4@7WDH4y~JBA&T<_b8FxlZ7d1RfT6p~YD* zsfVb=y?Sf#;q!zKzFqKVyY~i7;X5tv+TGy^!AIU-?-lqRLjIE$r~Kr9Fla8mV{ymd z;pYUO8wHnrvAqQGVUI_QHRvbd|Sdk%fn;;vkWpAme%BJ?(Ql1We= z*?*e_F6n!G@V6}Pwda!-_v-B(AN;%zo@p1GynN0>Pd}O<9vbeXsUJ&%!4_Nv4c<@CQf6?NuUWFFl>%kqpa~7=cT2bGyHNH#q zX>saP%AYUjC0-}!DgP8JPlLssoDOfXxL5x>1un<&9)a6aU5j%9mwqP8PX5S$s;KV_ zi+k%k*W%88He30l9=zS+^DXY`<>(iAa7XXH5A*8NZri2T*`z)gkmw1L%meYfKKPJ=SuD%Y>u{h|a{1@4Ny3@no;rj(2+23Cge54+Z3Y_-r`um$6{tkaj@RxcxX>qT;xtCGAc($F~ zc=1U-c)kyQzr|fU#;kr~7I*FF@M?>*9b1H+TLf-hi@w@xaj%?7K_3=;GVP><{N=bX zN#NEbb*@Dgr~I;A$^`wV1pj+2?v^#;wjhRj|e`}4{R2=Y_B~Q_uB1V!C%UGNbs?)Ma!9CZ!(?!7h5@pTiof#;aL`^ zeai7P$HQm49q%T1_&9u$;3NI&3=f|@mQTKikHhEs@L44INIfjJxL0qrg3rUU9R)7s zj0^s_?j|?)2&U(GwQ;_S5YiKJGo;golsA_gI|mBJJlDf!`+T^_GW!!nXTK z4}XWhBltWb_+;6eXO{a_flm;)>=*Z1+}YcCTkic9@7IsTV}g(D@3j{9wqvKDw=Pyo zm9#hWl=D#`=LH{p_)J4Ydh3cbFiqh13O-SR+peas-Yf7g3HoY_Qx7!p%qz^rI*U^e z5`RSSk?Rsq2zNP^QxCGg*IL}$e-nbw zM#1MLAN-KuKMM4g^>DpEH(EuZNGr5Bl(V$HQmOAft>k9=yTg=REu!{do`W=pUJ5 z_)-4Hgr0{N4&bss-XZX>3Hn-#vt5b>-e7U|3yJR(d^QXEtfGN(r99Jo@VP#CyTIlA zD zoy++{RPd4h{9cQD{rP6W=j)=rFA6^N+uN-?Jr;NJIDEh0Bkkv)hfm=UQ^;!`J`O)B z_{e&l61beVoENy9pQt~%Sf9$4JKW+GWIVZVn@)cVO@4tgP*cE+p$p% z{Lc8$XOiIb{;t2!^h!^eE8fiaOr271^#D3Kie(t z^pIoqu+!pB4-QWVK9dC>cglTR?{oThw$^ZzzKZ?nnMnq@yVK%qP`Lih`qQPm{I33-zOsm!_>;f$^Gu5SM#`Vd@5G{y=ehHnk&7733G{v)Itq1$W#M3=D7#sK33W zeOPSr-T@(^`ZS7nzpqrEJpALXPeQ8W?9xD2HnzAwi+G-Gh&_njoC+iMAkSli#raTi zj+mhRG>B2#e?CT>BQ|Y6j+nFk=Xv7%I&nT#oKHvm&7~z>pFI52JzXV0mwx>5#{(3SrTIc;iP;EK)$Mimz?m^lwPrp8gDa6Ot zuc34%^ykd+C1;0`_fIYFQBx^bG@YIene;hiU(L9plJ1j-U+OAHOkr2obD=;tWq<#^ zVAlsYZ$l`QB#u8yr?)WOeQh&PAO1-Vox$ zUQny|jodZvDDp8TaUWy1B3>->hqG1TS@4Ws8!haG?8l&=TmOhy#A8$;u{dOAjQCc> zb=5k%uM}Yn91H~+CEzXac4K0@mZMqJ&Y z-~-uDf~L@x-G_6wcQ`}!u+3flNe3NFWt&rfv<0?3?ZLGz;?$pxp#G4Zx|!;2*8r}S zrOW4#K9FHz-O_IQhU^;WM^BtK@yWw~D`W}icA%a=gbZv4%Cr_bpiIYB1y+X{gO}w% z&K|@SrktdqjBSwbSWvA#idf#~Ms=d>Y$Gf5N&SBE@IPstA|C0xN0Il6bh>PGruxO& z!K$P8!8L`s&4JYwXczKMhQ{>A-X(85o9q51>@Hy;8rY5S?HA7U# z(cm>(n6DJ=M43>wmK}59*&BvNi^{=!eol1#%R^MzPak}!kk=j7ix}n5?_svjiH(7d zlh93-3T&x7lUo?9ttgBjwt7D;>R23A@4gH%7*B za8yZPJZHbp4XM+6Aa`O|d`SX!yLNE2XgB0w-JGoIW5nu4J^u+f_9*E1M;wEw3w8T? zFndcM_`Q#F@;o+J715^8**bOL-1w)L`t5^#ly>mpc$NAPwow9^ij^uF1>FrpUnHNl zAF40x`mS0XK^)={x1FCtU~br1Vj#p)=6&YO^m)n1cI!8j$RPRTvN3UmpkG)pnIC+l4lbN8?M-&JQNS@Nc0<-=puN-}`Xn zt{pMx1nYcBR2O))pP!u!h$%;OI*X4(57FpUMd6q5%x`;MXxsT&hwyS z){*`iF{ihkeHL+oA)m`fS`}11DIEJkIa7Xk~H>k36 zO)B*P;#z+IKVYtp>Hej?-iN;N!8%-rEy(NtVz0l9e)hq`rrnS4;@GD;PM~}@zvQ?E zTPrKk{npGu*=Lhisvh?B#ObuQt@V&|EA-{;v<3AV4co%_vLv|;F~Ko+r@u+VkMcbE ztWBdo>iF1@$JBp(cks&iVO@8R&CvFw-NaEo`x51&4P4azXVYbD=S$lEy>x!th>P1l zawc6y`);GVb}@=J>%n059goGL2u{aXXs;o|3{3+Xt%TA zIR<(lua~V3cub;I#+unl;9-mvxuJFMCC5cS+WjA9ezgI7B6^Nz z_$PDp_Dbz&Z^Er3vJ(VsyB6N=Vqm5xd;3w}slb&6rWgOL=gJT@Fw-xg?+Gjk|*k=I#iF2!B z_@`Rj6{bMrC;zBXFOVD&MbG zmuA2}LN~=%snr-y%fgti6%A2We|e(nD8M+z^0kjexmREg&wfMO$*l{lF8PC-|Bvpb z&Gffrt4j6JXP`ZwK-;7D57NIPk9yh!f5 z>~)N_)^5!`d;)Wg_;j@KbkoMMR9d$Y{m`F6{xzc6Q0Nkt!9#+D9DgXO~iT3}0QZT5yVMxf^Bn%(zi$ZEtwK}JhJxK6R%Pn@ zZiasJ_dm+`Wci*UyvB8_EFYzg8pwon~(J6 zbX5lYZ)|x-SzcB&^;M)l2#uYZ&H9C-sfXXie( zlnmu)A5K|5%vL>^5A+03{{-|<48L80_B1bU@TS#}ch zvFE@O&t=-lXA{~v3jTeePbS#~c^WOxml!w+Q_f&&AsDn5+FSkp4aX-a-3f-@P6@lWhM7q{rgC z3wCw`)-$FAqD5L}T#MjZ?%%`Sapd^Xofl2L4ZAA=&2IPs(vjvnuva|yX~)`H$7%G- zcgCx(-(ejE>vH|F{riw$7v|~RZ%+($oyIyT^+P)*589j4&uwf!U@VjRO2FsF|B&u! zgHQQ4j9SKE#FLlhmqpu@Po4y@Dk4KPx=G0XM z=U^kwwzGk;t+_tBALVVw{H`8Y51zRkJ(t$y;hq}vPjlZye%Muf%a|f zi|gN{WBpvc?giaZAv^mO?5)Db@4T|D9gvz>1@Aqahc^?UN*~96{K;C)gJHPqOZ+`RlnVDyXb7Vim zAInb*uysNBXwB$gV_R-ml6-0M>ICMeIkse-;Fwg?bpn0S_aT?+m~vu%?aE_lf5?|{ zlP~#`_m>cs&%}R$Kl)VxW50KH%|SCy%DLaf6wI~B7z67mGdOp825}un-TM%IAm>ck z_i_I7;5E0uoCt%eU*g?>eP3G<`aZrBpzlk>VWaPhp+CH;C)hXKrjOH zlbEN>$GQX8j<$~uiaJqGmyX69y|i~Mvv}V)fHn~G+;+}~W%tVWtBYChdbbA;-7{kQ z_J5D}#W3ibNA0;KIIs@9C_8BqXdk=L&n6zY8B0khkKmQa8gJf5*P*_UH~Sve0lMRu zm*q3pTR6`#2k&GY_waq-3)C6sn4nMgr7`I3sziUi_F#^RaZ^WW{oI7K-elVzw5ynZ z?`vDBr>;2|XJzBvzu40J1~N@SxjL0SamKOv!D*~h=dHy%Y+`0mwf2MHp`1}zhr#o4 z%x!SqW*zcm&1JUjXqy}sccC5Ty56y@rza+71am15=Z2p^9NlxB(N^z59V19P%g%= zaxotACI9bcaZJJWN8yipkhltbQ2tpL@UB-ynMluYq-D4?J?caP^Kl$kF^*%-+x9(MR>mOwRq>culNnpc^Y+t?IPR6_ooF#XVAaj3^(+Sv|TY{ZT6(Mna^v#3Rxz>Mx1|y zI&sA*J5T&Q%pKi3cFXox!FLntRSNY)+b5R6-%!_BQ)RlDF18z-r))zz&vAqHpHq;Y z1o}?Sb%%)W5y*NR^EJoOCN4OGxl^=J3ABYwPXhds58P6Gd{ZgvBipO1_GLq!W2UXj zH+{8vhQ1je=R=PpU-%Ao^=V6oHpRG&JSgK@-dN5#XHK1UWuaX_JIprtY4mO5QMRVT zZ#>Gw^|ZS&jw%RFUx(+b;{D6re+B(_uB~|asvx%UqwM?{>`%T2EEpA*kau{tw}`y? zjCGqL+8kTwFg~CV}23y zVzG%qRUC1!-VmoQ|2yhg0<`o`!kvIW{bG1#{$o$Xj5(KuCC?8JF24nFvwXCn9{+U^ zJj?lUmN%^3&hA2+j(q+C^FYfRboFd+R#3w5D?poI{-E8&`q-5{%fmy#E4@W*NB;_L zww()L|2fKYKI9|57w(7g%y!1jgYN?GM*fFb-~I5FFJe7m!amO3{^LizTNB{PvW0eG z-?#C;z_Rsq#7%5U!1sYHQx{m~>7TBn!If_(G5<=sZI~Z!!hg?+Hw4$VU!!?ucTNY>bUe;pKT*{dGw5t4aO$05Nl(3V&a>@IuW3seAKTNvWqh#N1|GsQ?Z0N&tn8d&!$;&^ zGIG@DOUGO`_VRI8{k1&GmY)dG8*L zUXo|-F(uBc{a|o?W3rJKYl=Lx3+K-&z`xnz{_?aLMRUI#CEZu1)l6$5n_$|EFaPmZ z`kcYE##)2x&$Lyu^uK{1mq{Dt;set`o9Up?b`>}ni>83&dx_%pOi$HaH$?8+|Nl+_Vi{*xcS{K}Z1 z0I+<{7j#*gf}O*64O_G+rz3lFR@KO#{P>5YD;>2&p6uBYHdp05`#!$6f&OJuFE(}% zECf&8FMr1J4|nG78d1J!c*n5v%{g1L7k9?CW_|JKYYV~uRTI^ike>A0n$;O2wcY#r z7Q@4|^QUZ#k+Y0)mT%7bT%VwKsGt=f%SUCRnUsZ}(lPC^o#S?0Ubbm$$7SW4$85QD z>*&r=_af+PMWlNEZmc5Rk)KjhSdIitm)t3&6TDCRo zOJt;cK(Zfyof4*zn_ElAbZ70HzUzjvr>@!Y2j!ct@0eD;dFqzywqDyg<<9Msx5cx* zHS!Haop|H*yTR&5Z}v%5zAe6e^5e#LmHE8~zh(VtzGyt^%x`(b?+Sx2Grw6jz`rq$ zGV^QiJzqjy!Q@%Xlp~B|j49%8S-KqECfOX!1iW5o8kuG(6N^~ZvKAvbwiJEVJ_M&g zf_;|8e1J(H>LymYbIh(w%QlVf7*)RIlFcK_J4bBItsVL54@-}}w&=${u?+6B?oxGE zz52s46drMc34?DQx#g0rxt${nzwN`e4Zr*7Yo$;aSgF^&!e`WNhJTsj+lFr+cDp4# z`r2(HHJY^l5)x#!y#B_$d|3GU8|5Z^nlI6Np31r7N1u}jn4`;`XOv&)XFn##XfPki zw711}j@@-x+2+w(MwNA3x@k=Lj$uy?U)Xuc){$k~M{LW@N{&PV-uzM7D=#A%rK7T# zU1e|nsQi_ek@!;999Ftg>jVY71O)3%V>&J+=ck767{+Ms8VR~SicuBTon~{7@m8n9 zVC%@vOSa{1AEAtpFA#@9y!j)CoN+N8Q==i*$8gB{I^wo$Aam)cMXw!w{f*l-o~$qQ z_g&WCd0T&HX@93-b(^v(>+gvY*)Lv`7ny!olyidjdNcWD2lO3ivIEIn&np|8d}Djl zfqb}^JR`Lj-y^twlVjRV zU=IpDoplw)v}g7asU0RyeO8-!9Ed*wJm%0(=?elr!rZ~y%=18;a5i4jeA8xtOVVwZ z>z^IqEk1+E#^RoDz5!sY55m1O0^c2h|3w7;pCa(@M&K_-;Ov_+$$2sYe>VdEC<14} z&%}Q;%2OtMLIfU{DBDkp$PonMc_|H;M*c_ z*0)UZABw>LTLk__1pdni{8R*vM!@K~a~zZlqka1&z%$7?LFo0a6w~h`+zo>39Ve!* z2VNxjQekZRbl{~C{O^gtYa;Mg;a_<*n8KKT6ZX0Y`b`n|QxP~f4`k9qfLrO4Ee*43 zf~l*6`&ZW0RRgd$f8!knSG@Dxr8-sDLc*H*eQE#lqx+d%2kg92FMU>|9^oCTbg}lVEd}XqwKB!?#D^g7@ zD;t_x?>9VBElq}{wVG=5M)?{Xl!k0s!l;c z_y&?*DojJFwqbcgD>1OLER5#BaXEt2*0m-Z8dHd`A=O+{Qc|6w%I~*?wRN@4t@z(? zzlaPa)YjEB*Vb8mfN4|RL#vXFmi?+m3p4YK@@nw1N?DEasKA=Wx?~enlLn}#v}3tm zL(c>xQ;28Q6x|I*t)l#&THOTLBk~E}N zTYZRYRZC0VO4N(dtRyg3pgq7|$+XdW&$AO;JT4SIJ~IL@j==f8N8|IUwD17@z6iWN z0&k7L+amBMBk;}${D9!po7)~76rA7ayEyx08lF|aiC8uIu1Y*#LD(P2vyZcXq#=Hl zeKfxX5qQGECpz@{O*#2UQ)zrRIP@Gts_7A2)2kz@lY(n{71wXa$=^LQ<2kgSG`{@Z zf|EbTv}%qBPW~?blEdd3C5D|NLu&GO^{HoH`tjBay{4;Jc(n+w=~BGa;qS(K*yE#l z|Dwl7@s}JvlO6fbczg=PFGpSpR363k?sTRr?(k_7dZufNgKrR=_0Gi)3Qj)PI`pqN z_;n86gr0hH<=^4pGaNY&IQ*F}ZQ^%OaLpIR z4?BE5Ewr>=a&TAA)8*BU@@St$`dc0RMgn5oJD({}kKn6?Ugc5zafgrF?yVQx*PDJ* z?(0qOO!muLzMTj#{k5CFalw5)y9Fm7w>}@>KN*3K9&H8l)7#HL^3S8w|re6}M$_J|sz`4u1>jowA9`K9=~ z4xd6xYJN|7eCoyTjNr;g@nDQ4V7yZtK6-oORY((TU$C2}};J*BNC$KNS-sP)$eph%EGchnKzv2~wGhVlSSR%L|?^412 zcvnZz>z%+V&q*sruwLj@9>q6A@YlP7mCpv@)8+9|e2?Hvms@^%1Xn(t!si{2kK*q} z@EMDZH#Ev87xB>K3$E!>JTAB|&vcJZi)9nc^!O-V<R>A#vANTmImU!DdJR$gckH6Ay@NlKq`99{aEa4kYyM>i@zhd&;OJ|@A997%@H)DpJE@)Z(MM{J=8P2eEM4>=&K_5FO8sYiJ)(dpw~N= zeR=Rvt}(v+diSzVk8jB{(jShH=ST#7PXzs25%gyw=ygKam%l(Jj3~dG@3#t0dKW+F z(7XBjoI~&8?+DI%G25!d{C?o@arvKd__+9z@iwrp=Sso-bWNAQq#ui*Z8mtIcPwkW zr+9(TQ_d2hrFE;vN9Suo!Ih8VOFa5|@S~~p=oQDNRbv>h?mZ#U>EP}-f4{?jiVbRh z4+!q-Ay+1?$p03HeuLnupHTds6kOA#c!$HsmFJ9uyYFi``IaI1PZ!>_Mhi|kT|Dm4 zoBV=5&2+(4o;JbjJ^GWDJZSXj6@T2LFBU#+9=+mv*R<-VLg=6L_=JMDdwi6>!^4%n z%j2W*?)K;vKj_hGx}Nj!N|C4ALPJY4B}JU&Z>&s!e7;_rC$TK?bl=oQbA!lC-y zApCO$*Zfs{lHh*5nCkG6B5!hjrr>^iRqW8STxoi563ZDbuXvlo$9<1j@9=Ts-5|JMuiG7Zrc3j;LvT%(;x7qK`Q_21=gkPbM{vLX zz9YC_f5*xsHTk>q6;lP*d|xg4(Ywl3PQ~53%3b{|@%X4ds{~g*iZ6BKarv}*d{jTH zJzUGf;~sydZ}V`a-{A34`X@bl#rH?hABdno;?akq&sRKp#m{*38m}%MsNNKh%c6qj zm+~nPTL)^zS(QUHUT-_(CaszJBf#+^=8tg8TKW&7o&~&y_T65M1*`@#h3*yz*#5 zyyD=War7`+7DXtJo31>;DUXZqj-Y=gg8n&KETKF%I`N)#aJO9=8@EKHcjy0SI(V_e zr$}(Wyxl6eU*48D^wg)C%D8<}eJWlhIOUNckMUaV;L`OOywkz|&>;3_zk|ER#e z@^|$xU2wmg6bbH^lS+q=+YUeJ@Nx68)8XUdyCd-K2>dO30ZDdE9Zx9tU^jIpE--qtAC8+%1P%*~s6;mq;b_@m9fo`P&5d z<=+s2>mAxYpY8~HX>QYJt83CUjl&>+7Qp@D(JHp$+Fy5hco)LaoU~S&e;1j-OcH

?$6@K`83K$_f`E4XPo~} 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 Tr|p{7Mbl9a)#?Ae>-7H*`~Ylz literal 0 HcmV?d00001 diff --git a/third_party/libcurl/uos/aarch64/lib/libcurl.la b/third_party/libcurl/uos/aarch64/lib/libcurl.la new file mode 100755 index 00000000..9b65a0a7 --- /dev/null +++ b/third_party/libcurl/uos/aarch64/lib/libcurl.la @@ -0,0 +1,41 @@ +# libcurl.la - a libtool library file +# Generated by libtool (GNU libtool) 2.4.6 Debian-2.4.6-15 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='' + +# Names of this library. +library_names='' + +# The name of the static archive. +old_library='libcurl.a' + +# Linker flags that cannot go in dependency_libs. +inherited_linker_flags=' -pthread' + +# Libraries that this one depends upon. +dependency_libs=' -lz' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libcurl. +current=11 +age=7 +revision=0 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='/home/huagao/sane/code_app/third_party/libcurl/uos/aarch64/curl-7.82.0/release/lib' diff --git a/third_party/libcurl/uos/aarch64/lib/pkgconfig/libcurl.pc b/third_party/libcurl/uos/aarch64/lib/pkgconfig/libcurl.pc new file mode 100644 index 00000000..e5f675d0 --- /dev/null +++ b/third_party/libcurl/uos/aarch64/lib/pkgconfig/libcurl.pc @@ -0,0 +1,39 @@ +#*************************************************************************** +# _ _ ____ _ +# Project ___| | | | _ \| | +# / __| | | | |_) | | +# | (__| |_| | _ <| |___ +# \___|\___/|_| \_\_____| +# +# Copyright (C) 1998 - 2020, 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 https://curl.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 should most probably benefit from getting a "Requires:" field added +# dynamically by configure. +# +prefix=/home/huagao/sane/code_app/third_party/libcurl/uos/aarch64/curl-7.82.0/release +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include +supported_protocols="DICT FILE FTP GOPHER HTTP IMAP MQTT POP3 RTSP SMTP TELNET TFTP" +supported_features="AsynchDNS IPv6 Largefile UnixSockets alt-svc libz" + +Name: libcurl +URL: https://curl.se/ +Description: Library to transfer files with ftp, http, etc. +Version: 7.82.0 +Libs: -L${libdir} -lcurl -lz -pthread +Libs.private: -lz -pthread +Cflags: -I${includedir} -DCURL_STATICLIB