From cc17a960a918143c83ec4a6bf66ef14bc1ca73dc Mon Sep 17 00:00:00 2001 From: flowtron Date: Wed, 3 Dec 2008 02:02:20 +0000 Subject: [PATCH] using Toca's-improved-acfan-JPEG-screenshot git-svn-id: svn://svn.code.sf.net/p/actiongame/code/trunk/ac@3844 e016b1c5-ed68-44aa-a2f7-31cac88cffde --- docs/reference.xml | 12 +- source/include/jconfig.h | 45 ++ source/include/jerror.h | 303 ++++++++++ source/include/jmorecfg.h | 426 ++++++++++++++ source/include/jpeglib.h | 1118 +++++++++++++++++++++++++++++++++++++ source/lib/jpeglib.lib | Bin 0 -> 264186 bytes source/src/Makefile | 2 +- source/src/clientgame.cpp | 6 +- source/src/main.cpp | 88 ++- source/src/pch.h | 1 + 10 files changed, 1990 insertions(+), 11 deletions(-) create mode 100644 source/include/jconfig.h create mode 100644 source/include/jerror.h create mode 100644 source/include/jmorecfg.h create mode 100644 source/include/jpeglib.h create mode 100644 source/lib/jpeglib.lib diff --git a/docs/reference.xml b/docs/reference.xml index 4b33cdd0..4cfd4793 100644 --- a/docs/reference.xml +++ b/docs/reference.xml @@ -449,12 +449,14 @@ This section describes general identifiers. - + Toggle for taking an automatic screenshot during intermission. - - - - + + + + Toggle format of screenshot image. Your choice is for BMP (0) or JPEG (1). + + Plays all hardcoded sounds in order. diff --git a/source/include/jconfig.h b/source/include/jconfig.h new file mode 100644 index 00000000..5cafaa25 --- /dev/null +++ b/source/include/jconfig.h @@ -0,0 +1,45 @@ +/* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */ +/* see jconfig.doc for explanations */ + +#define HAVE_PROTOTYPES +#define HAVE_UNSIGNED_CHAR +#define HAVE_UNSIGNED_SHORT +/* #define void char */ +/* #define const */ +#undef CHAR_IS_UNSIGNED +#define HAVE_STDDEF_H +#define HAVE_STDLIB_H +#undef NEED_BSD_STRINGS +#undef NEED_SYS_TYPES_H +#undef NEED_FAR_POINTERS /* we presume a 32-bit flat memory model */ +#undef NEED_SHORT_EXTERNAL_NAMES +#undef INCOMPLETE_TYPES_BROKEN + +/* Define "boolean" as unsigned char, not int, per Windows custom */ +#ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */ +typedef unsigned char boolean; +#endif +#define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */ + + +#ifdef JPEG_INTERNALS + +#undef RIGHT_SHIFT_IS_UNSIGNED + +#endif /* JPEG_INTERNALS */ + +#ifdef JPEG_CJPEG_DJPEG + +#define BMP_SUPPORTED /* BMP image file format */ +#define GIF_SUPPORTED /* GIF image file format */ +#define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ +#undef RLE_SUPPORTED /* Utah RLE image file format */ +#define TARGA_SUPPORTED /* Targa image file format */ + +#define TWO_FILE_COMMANDLINE /* optional */ +#define USE_SETMODE /* Microsoft has setmode() */ +#undef NEED_SIGNAL_CATCHER +#undef DONT_USE_B_MODE +#undef PROGRESS_REPORT /* optional */ + +#endif /* JPEG_CJPEG_DJPEG */ diff --git a/source/include/jerror.h b/source/include/jerror.h new file mode 100644 index 00000000..fcdf6a83 --- /dev/null +++ b/source/include/jerror.h @@ -0,0 +1,303 @@ +/* + * jerror.h + * + * Copyright (C) 1994-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file defines the error and message codes for the JPEG library. + * Edit this file to add new codes, or to translate the message strings to + * some other language. + * A set of error-reporting macros are defined too. Some applications using + * the JPEG library may wish to include this file to get the error codes + * and/or the macros. + */ + +/* + * To define the enum list of message codes, include this file without + * defining macro JMESSAGE. To create a message string table, include it + * again with a suitable JMESSAGE definition (see jerror.c for an example). + */ +#ifndef JMESSAGE +#ifndef JERROR_H +/* First time through, define the enum list */ +#define JMAKE_ENUM_LIST +#else +/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */ +#define JMESSAGE(code,string) +#endif /* JERROR_H */ +#endif /* JMESSAGE */ + +#ifdef JMAKE_ENUM_LIST + +typedef enum { + +#define JMESSAGE(code,string) code , + +#endif /* JMAKE_ENUM_LIST */ + +JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */ + +/* For maintenance convenience, list is alphabetical by message code name */ +JMESSAGE(JERR_ARITH_NOTIMPL, + "Sorry, there are legal restrictions on arithmetic coding") +JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix") +JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix") +JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode") +JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS") +JMESSAGE(JERR_BAD_CROP_SPEC, "Invalid crop request") +JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range") +JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported") +JMESSAGE(JERR_BAD_DROP_SAMPLING, + "Component index %d: mismatching sampling ratio %d:%d, %d:%d, %c") +JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition") +JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace") +JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace") +JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length") +JMESSAGE(JERR_BAD_LIB_VERSION, + "Wrong JPEG library version: library is %d, caller expects %d") +JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan") +JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d") +JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d") +JMESSAGE(JERR_BAD_PROGRESSION, + "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d") +JMESSAGE(JERR_BAD_PROG_SCRIPT, + "Invalid progressive parameters at scan script entry %d") +JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors") +JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d") +JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d") +JMESSAGE(JERR_BAD_STRUCT_SIZE, + "JPEG parameter struct mismatch: library thinks size is %u, caller expects %u") +JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access") +JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small") +JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here") +JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet") +JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d") +JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request") +JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d") +JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x") +JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d") +JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d") +JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)") +JMESSAGE(JERR_EMS_READ, "Read from EMS failed") +JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed") +JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan") +JMESSAGE(JERR_FILE_READ, "Input file read error") +JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?") +JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet") +JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow") +JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry") +JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels") +JMESSAGE(JERR_INPUT_EMPTY, "Empty input file") +JMESSAGE(JERR_INPUT_EOF, "Premature end of input file") +JMESSAGE(JERR_MISMATCHED_QUANT_TABLE, + "Cannot transcode due to multiple use of quantization table %d") +JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data") +JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change") +JMESSAGE(JERR_NOTIMPL, "Not implemented yet") +JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time") +JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported") +JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined") +JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image") +JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined") +JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x") +JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)") +JMESSAGE(JERR_QUANT_COMPONENTS, + "Cannot quantize more than %d color components") +JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors") +JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors") +JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers") +JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker") +JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x") +JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers") +JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF") +JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s") +JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file") +JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file") +JMESSAGE(JERR_TFILE_WRITE, + "Write failed on temporary file --- out of disk space?") +JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines") +JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x") +JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up") +JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation") +JMESSAGE(JERR_XMS_READ, "Read from XMS failed") +JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed") +JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT) +JMESSAGE(JMSG_VERSION, JVERSION) +JMESSAGE(JTRC_16BIT_TABLES, + "Caution: quantization tables are too coarse for baseline JPEG") +JMESSAGE(JTRC_ADOBE, + "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d") +JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u") +JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u") +JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x") +JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x") +JMESSAGE(JTRC_DQT, "Define Quantization Table %d precision %d") +JMESSAGE(JTRC_DRI, "Define Restart Interval %u") +JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u") +JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u") +JMESSAGE(JTRC_EOI, "End Of Image") +JMESSAGE(JTRC_HUFFBITS, " %3d %3d %3d %3d %3d %3d %3d %3d") +JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d %d") +JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE, + "Warning: thumbnail image size does not match data length %u") +JMESSAGE(JTRC_JFIF_EXTENSION, + "JFIF extension marker: type 0x%02x, length %u") +JMESSAGE(JTRC_JFIF_THUMBNAIL, " with %d x %d thumbnail image") +JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u") +JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x") +JMESSAGE(JTRC_QUANTVALS, " %4u %4u %4u %4u %4u %4u %4u %4u") +JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors") +JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors") +JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization") +JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d") +JMESSAGE(JTRC_RST, "RST%d") +JMESSAGE(JTRC_SMOOTH_NOTIMPL, + "Smoothing not supported with nonstandard sampling ratios") +JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d") +JMESSAGE(JTRC_SOF_COMPONENT, " Component %d: %dhx%dv q=%d") +JMESSAGE(JTRC_SOI, "Start of Image") +JMESSAGE(JTRC_SOS, "Start Of Scan: %d components") +JMESSAGE(JTRC_SOS_COMPONENT, " Component %d: dc=%d ac=%d") +JMESSAGE(JTRC_SOS_PARAMS, " Ss=%d, Se=%d, Ah=%d, Al=%d") +JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s") +JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s") +JMESSAGE(JTRC_THUMB_JPEG, + "JFIF extension marker: JPEG-compressed thumbnail image, length %u") +JMESSAGE(JTRC_THUMB_PALETTE, + "JFIF extension marker: palette thumbnail image, length %u") +JMESSAGE(JTRC_THUMB_RGB, + "JFIF extension marker: RGB thumbnail image, length %u") +JMESSAGE(JTRC_UNKNOWN_IDS, + "Unrecognized component IDs %d %d %d, assuming YCbCr") +JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u") +JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u") +JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d") +JMESSAGE(JWRN_BOGUS_PROGRESSION, + "Inconsistent progression sequence for component %d coefficient %d") +JMESSAGE(JWRN_EXTRANEOUS_DATA, + "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x") +JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment") +JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code") +JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d") +JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file") +JMESSAGE(JWRN_MUST_RESYNC, + "Corrupt JPEG data: found marker 0x%02x instead of RST%d") +JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG") +JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines") + +#ifdef JMAKE_ENUM_LIST + + JMSG_LASTMSGCODE +} J_MESSAGE_CODE; + +#undef JMAKE_ENUM_LIST +#endif /* JMAKE_ENUM_LIST */ + +/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */ +#undef JMESSAGE + + +#ifndef JERROR_H +#define JERROR_H + +/* Macros to simplify using the error and trace message stuff */ +/* The first parameter is either type of cinfo pointer */ + +/* Fatal errors (print message and exit) */ +#define ERREXIT(cinfo,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT1(cinfo,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT2(cinfo,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT3(cinfo,code,p1,p2,p3) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (cinfo)->err->msg_parm.i[2] = (p3), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT4(cinfo,code,p1,p2,p3,p4) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (cinfo)->err->msg_parm.i[2] = (p3), \ + (cinfo)->err->msg_parm.i[3] = (p4), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT6(cinfo,code,p1,p2,p3,p4,p5,p6) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (cinfo)->err->msg_parm.i[2] = (p3), \ + (cinfo)->err->msg_parm.i[3] = (p4), \ + (cinfo)->err->msg_parm.i[4] = (p5), \ + (cinfo)->err->msg_parm.i[5] = (p6), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXITS(cinfo,code,str) \ + ((cinfo)->err->msg_code = (code), \ + strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) + +#define MAKESTMT(stuff) do { stuff } while (0) + +/* Nonfatal errors (we can keep going, but the data is probably corrupt) */ +#define WARNMS(cinfo,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) +#define WARNMS1(cinfo,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) +#define WARNMS2(cinfo,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) + +/* Informational/debugging messages */ +#define TRACEMS(cinfo,lvl,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS1(cinfo,lvl,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS2(cinfo,lvl,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS3(cinfo,lvl,code,p1,p2,p3) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + _mp[4] = (p5); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMSS(cinfo,lvl,code,str) \ + ((cinfo)->err->msg_code = (code), \ + strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) + +#endif /* JERROR_H */ diff --git a/source/include/jmorecfg.h b/source/include/jmorecfg.h new file mode 100644 index 00000000..f54191b0 --- /dev/null +++ b/source/include/jmorecfg.h @@ -0,0 +1,426 @@ +/* + * jmorecfg.h + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains additional configuration options that customize the + * JPEG software for special applications or support machine-dependent + * optimizations. Most users will not need to touch this file. + */ + + +/* + * Define BITS_IN_JSAMPLE as either + * 8 for 8-bit sample values (the usual setting) + * 12 for 12-bit sample values + * Only 8 and 12 are legal data precisions for lossy JPEG according to the + * JPEG standard, and the IJG code does not support anything else! + * We do not support run-time selection of data precision, sorry. + */ + +#define BITS_IN_JSAMPLE 8 /* use 8 or 12 */ + +#if (defined (_MSC_VER) && (_MSC_VER >= 800)) +#define HAVE_UNSIGNED_CHAR +#define HAVE_ALL_INTS +#define EXTERN(type) extern type __cdecl +#endif + +/* + * Maximum number of components (color channels) allowed in JPEG image. + * To meet the letter of the JPEG spec, set this to 255. However, darn + * few applications need more than 4 channels (maybe 5 for CMYK + alpha + * mask). We recommend 10 as a reasonable compromise; use 4 if you are + * really short on memory. (Each allowed component costs a hundred or so + * bytes of storage, whether actually used in an image or not.) + */ + +#define MAX_COMPONENTS 10 /* maximum number of image components */ + + +/* + * Basic data types. + * You may need to change these if you have a machine with unusual data + * type sizes; for example, "char" not 8 bits, "short" not 16 bits, + * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits, + * but it had better be at least 16. + */ + +/* Representation of a single sample (pixel element value). + * We frequently allocate large arrays of these, so it's important to keep + * them small. But if you have memory to burn and access to char or short + * arrays is very slow on your hardware, you might want to change these. + */ + +#if BITS_IN_JSAMPLE == 8 +/* JSAMPLE should be the smallest type that will hold the values 0..255. + * You can use a signed char by having GETJSAMPLE mask it with 0xFF. + */ + +#ifdef HAVE_UNSIGNED_CHAR + +typedef unsigned char JSAMPLE; +#define GETJSAMPLE(value) ((int) (value)) + +#else /* not HAVE_UNSIGNED_CHAR */ + +typedef char JSAMPLE; +#ifdef CHAR_IS_UNSIGNED +#define GETJSAMPLE(value) ((int) (value)) +#else +#define GETJSAMPLE(value) ((int) (value) & 0xFF) +#endif /* CHAR_IS_UNSIGNED */ + +#endif /* HAVE_UNSIGNED_CHAR */ + +#define MAXJSAMPLE 255 +#define CENTERJSAMPLE 128 + +#endif /* BITS_IN_JSAMPLE == 8 */ + + +#if BITS_IN_JSAMPLE == 12 +/* JSAMPLE should be the smallest type that will hold the values 0..4095. + * On nearly all machines "short" will do nicely. + */ + +typedef short JSAMPLE; +#define GETJSAMPLE(value) ((int) (value)) + +#define MAXJSAMPLE 4095 +#define CENTERJSAMPLE 2048 + +#endif /* BITS_IN_JSAMPLE == 12 */ + + +/* Representation of a DCT frequency coefficient. + * This should be a signed value of at least 16 bits; "short" is usually OK. + * Again, we allocate large arrays of these, but you can change to int + * if you have memory to burn and "short" is really slow. + */ + +typedef short JCOEF; + + +/* Compressed datastreams are represented as arrays of JOCTET. + * These must be EXACTLY 8 bits wide, at least once they are written to + * external storage. Note that when using the stdio data source/destination + * managers, this is also the data type passed to fread/fwrite. + */ + +#ifdef HAVE_UNSIGNED_CHAR + +typedef unsigned char JOCTET; +#define GETJOCTET(value) (value) + +#else /* not HAVE_UNSIGNED_CHAR */ + +typedef char JOCTET; +#ifdef CHAR_IS_UNSIGNED +#define GETJOCTET(value) (value) +#else +#define GETJOCTET(value) ((value) & 0xFF) +#endif /* CHAR_IS_UNSIGNED */ + +#endif /* HAVE_UNSIGNED_CHAR */ + + +/* These typedefs are used for various table entries and so forth. + * They must be at least as wide as specified; but making them too big + * won't cost a huge amount of memory, so we don't provide special + * extraction code like we did for JSAMPLE. (In other words, these + * typedefs live at a different point on the speed/space tradeoff curve.) + */ + +/* UINT8 must hold at least the values 0..255. */ +#ifndef HAVE_ALL_INTS + +#ifdef HAVE_UNSIGNED_CHAR +typedef unsigned char UINT8; +#else /* not HAVE_UNSIGNED_CHAR */ +#ifdef CHAR_IS_UNSIGNED +typedef char UINT8; +#else /* not CHAR_IS_UNSIGNED */ +typedef short UINT8; +#endif /* CHAR_IS_UNSIGNED */ +#endif /* HAVE_UNSIGNED_CHAR */ + +/* UINT16 must hold at least the values 0..65535. */ + +#ifdef HAVE_UNSIGNED_SHORT +typedef unsigned short UINT16; +#else /* not HAVE_UNSIGNED_SHORT */ +typedef unsigned int UINT16; +#endif /* HAVE_UNSIGNED_SHORT */ + +/* INT16 must hold at least the values -32768..32767. */ + +#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */ +typedef short INT16; +#endif + +/* INT32 must hold at least signed 32-bit values. */ + +#if !defined(XMD_H) && !defined(_WIN32) /* X11/xmd.h correctly defines INT32 */ +typedef long INT32; +#endif + +#endif /* HAVE_ALL_INTS */ + +/* Datatype used for image dimensions. The JPEG standard only supports + * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore + * "unsigned int" is sufficient on all machines. However, if you need to + * handle larger images and you don't mind deviating from the spec, you + * can change this datatype. + */ + +typedef unsigned int JDIMENSION; + +#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */ + + +/* These macros are used in all function definitions and extern declarations. + * You could modify them if you need to change function linkage conventions; + * in particular, you'll need to do that to make the library a Windows DLL. + * Another application is to make all functions global for use with debuggers + * or code profilers that require it. + */ + +#ifdef _WIN32 +# if defined(ALL_STATIC) +# if defined(JPEG_DLL) +# undef JPEG_DLL +# endif +# if !defined(JPEG_STATIC) +# define JPEG_STATIC +# endif +# endif +# if defined(JPEG_DLL) +# if defined(JPEG_STATIC) +# undef JPEG_STATIC +# endif +# endif +# if defined(JPEG_DLL) +/* building a DLL */ +# define JPEG_IMPEXP __declspec(dllexport) +# elif defined(JPEG_STATIC) +/* building or linking to a static library */ +# define JPEG_IMPEXP +# else +/* linking to the DLL */ +# define JPEG_IMPEXP __declspec(dllimport) +# endif +# if !defined(JPEG_API) +# define JPEG_API __cdecl +# endif +/* The only remaining magic that is necessary for cygwin */ +#elif defined(__CYGWIN__) +# if !defined(JPEG_IMPEXP) +# define JPEG_IMPEXP +# endif +# if !defined(JPEG_API) +# define JPEG_API __cdecl +# endif +#endif + +/* Ensure our magic doesn't hurt other platforms */ +#if !defined(JPEG_IMPEXP) +# define JPEG_IMPEXP +#endif +#if !defined(JPEG_API) +# define JPEG_API +#endif + +/* a function called through method pointers: */ +#define METHODDEF(type) static type +/* a function used only in its module: */ +#define LOCAL(type) static type +/* a function referenced thru EXTERNs: */ +#define GLOBAL(type) type JPEG_API +/* a reference to a GLOBAL function: */ +#ifndef EXTERN +# define EXTERN(type) extern JPEG_IMPEXP type JPEG_API +/* a reference to a "GLOBAL" function exported by sourcefiles of utility progs */ +#endif /* EXTERN */ +#define EXTERN_1(type) extern type JPEG_API + + +/* This macro is used to declare a "method", that is, a function pointer. + * We want to supply prototype parameters if the compiler can cope. + * Note that the arglist parameter must be parenthesized! + * Again, you can customize this if you need special linkage keywords. + */ + +#ifdef HAVE_PROTOTYPES +#define JMETHOD(type,methodname,arglist) type (*methodname) arglist +#else +#define JMETHOD(type,methodname,arglist) type (*methodname) () +#endif + + +/* Here is the pseudo-keyword for declaring pointers that must be "far" + * on 80x86 machines. Most of the specialized coding for 80x86 is handled + * by just saying "FAR *" where such a pointer is needed. In a few places + * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol. + */ + +/* jmorecfg.h line 220 */ +/* HJH modification: several of the windows header files already define FAR + because of this, the code below was changed so that it only tinkers with + the FAR define if FAR is still undefined */ +#ifndef FAR + #ifdef NEED_FAR_POINTERS + #define FAR far + #else + #define FAR + #endif +#endif + + +/* + * On a few systems, type boolean and/or its values FALSE, TRUE may appear + * in standard header files. Or you may have conflicts with application- + * specific header files that you want to include together with these files. + * Defining HAVE_BOOLEAN before including jpeglib.h should make it work. + */ + +#ifndef HAVE_BOOLEAN +typedef int boolean; +#endif +#ifndef FALSE /* in case these macros already exist */ +#define FALSE 0 /* values of boolean */ +#endif +#ifndef TRUE +#define TRUE 1 +#endif + + +/* + * The remaining options affect code selection within the JPEG library, + * but they don't need to be visible to most applications using the library. + * To minimize application namespace pollution, the symbols won't be + * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined. + */ + +#ifdef JPEG_INTERNALS +#define JPEG_INTERNAL_OPTIONS +#endif + +#ifdef JPEG_INTERNAL_OPTIONS + + +/* + * These defines indicate whether to include various optional functions. + * Undefining some of these symbols will produce a smaller but less capable + * library. Note that you can leave certain source files out of the + * compilation/linking process if you've #undef'd the corresponding symbols. + * (You may HAVE to do that if your compiler doesn't like null source files.) + */ + +/* Arithmetic coding is unsupported for legal reasons. Complaints to IBM. */ + +/* Capability options common to encoder and decoder: */ + +#define DCT_ISLOW_SUPPORTED /* slow but accurate integer algorithm */ +#define DCT_IFAST_SUPPORTED /* faster, less accurate integer method */ +#define DCT_FLOAT_SUPPORTED /* floating-point: accurate, fast on fast HW */ + +/* Encoder capability options: */ + +#undef C_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ +#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */ +/* Note: if you selected 12-bit data precision, it is dangerous to turn off + * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit + * precision, so jchuff.c normally uses entropy optimization to compute + * usable tables for higher precision. If you don't want to do optimization, + * you'll have to supply different default Huffman tables. + * The exact same statements apply for progressive JPEG: the default tables + * don't work for progressive mode. (This may get fixed, however.) + */ +#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */ + +/* Decoder capability options: */ + +#undef D_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ +#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */ +#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */ +#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */ +#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */ +#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */ +#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */ +#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */ + +/* more capability options later, no doubt */ + + +/* + * Ordering of RGB data in scanlines passed to or from the application. + * If your application wants to deal with data in the order B,G,R, just + * change these macros. You can also deal with formats such as R,G,B,X + * (one extra byte per pixel) by changing RGB_PIXELSIZE. Note that changing + * the offsets will also change the order in which colormap data is organized. + * RESTRICTIONS: + * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats. + * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not + * useful if you are using JPEG color spaces other than YCbCr or grayscale. + * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE + * is not 3 (they don't understand about dummy color components!). So you + * can't use color quantization if you change that value. + */ + +#define RGB_RED 0 /* Offset of Red in an RGB scanline element */ +#define RGB_GREEN 1 /* Offset of Green */ +#define RGB_BLUE 2 /* Offset of Blue */ +#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */ + + +/* Definitions for speed-related optimizations. */ + + +/* If your compiler supports inline functions, define INLINE + * as the inline keyword; otherwise define it as empty. + */ + +#ifndef INLINE +#ifdef __GNUC__ /* for instance, GNU C knows about inline */ +#define INLINE __inline__ +#endif +#ifndef INLINE +#define INLINE /* default is to define it as empty */ +#endif +#endif + + +/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying + * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER + * as short on such a machine. MULTIPLIER must be at least 16 bits wide. + */ + +#ifndef MULTIPLIER +#define MULTIPLIER int /* type for fastest integer multiply */ +#endif + + +/* FAST_FLOAT should be either float or double, whichever is done faster + * by your compiler. (Note that this type is only used in the floating point + * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.) + * Typically, float is faster in ANSI C compilers, while double is faster in + * pre-ANSI compilers (because they insist on converting to double anyway). + * The code below therefore chooses float if we have ANSI-style prototypes. + */ + +#ifndef FAST_FLOAT +#ifdef HAVE_PROTOTYPES +#define FAST_FLOAT float +#else +#define FAST_FLOAT double +#endif +#endif + +#endif /* JPEG_INTERNAL_OPTIONS */ diff --git a/source/include/jpeglib.h b/source/include/jpeglib.h new file mode 100644 index 00000000..e5fed222 --- /dev/null +++ b/source/include/jpeglib.h @@ -0,0 +1,1118 @@ +/* + * jpeglib.h + * + * Copyright (C) 1991-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file defines the application interface for the JPEG library. + * Most applications using the library need only include this file, + * and perhaps jerror.h if they want to know the exact error codes. + */ + + +typedef unsigned char UINT8; +typedef signed char INT8; +typedef unsigned short UINT16; +typedef short INT16; +typedef unsigned UINT32; +typedef int INT32; + +#ifndef JPEGLIB_H +#define JPEGLIB_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * First we include the configuration files that record how this + * installation of the JPEG library is set up. jconfig.h can be + * generated automatically for many systems. jmorecfg.h contains + * manual configuration options that most people need not worry about. + */ + +#ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */ +#include "jconfig.h" /* widely used configuration options */ +#endif +#include "jmorecfg.h" /* seldom changed options */ + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* Version ID for the JPEG library. + * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60". + */ + +#define JPEG_LIB_VERSION 62 /* Version 6b */ + + +/* Various constants determining the sizes of things. + * All of these are specified by the JPEG standard, so don't change them + * if you want to be compatible. + */ + +#define DCTSIZE 8 /* The basic DCT block is 8x8 samples */ +#define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */ +#define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */ +#define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */ +#define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */ +#define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */ +#define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */ +/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard; + * the PostScript DCT filter can emit files with many more than 10 blocks/MCU. + * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU + * to handle it. We even let you do this from the jconfig.h file. However, + * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe + * sometimes emits noncompliant files doesn't mean you should too. + */ +#define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */ +#ifndef D_MAX_BLOCKS_IN_MCU +#define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */ +#endif + + +/* Data structures for images (arrays of samples and of DCT coefficients). + * On 80x86 machines, the image arrays are too big for near pointers, + * but the pointer arrays can fit in near memory. + */ + +typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */ +typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */ +typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */ + +typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */ +typedef JBLOCK FAR *JBLOCKROW; /* pointer to one row of coefficient blocks */ +typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */ +typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */ + +typedef JCOEF FAR *JCOEFPTR; /* useful in a couple of places */ + + +/* Types for JPEG compression parameters and working tables. */ + + +/* DCT coefficient quantization tables. */ + +typedef struct { + /* This array gives the coefficient quantizers in natural array order + * (not the zigzag order in which they are stored in a JPEG DQT marker). + * CAUTION: IJG versions prior to v6a kept this array in zigzag order. + */ + unsigned int quantval[DCTSIZE2]; /* quantization step for each coefficient */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JQUANT_TBL; + + +/* Huffman coding tables. */ + +typedef struct { + /* These two fields directly represent the contents of a JPEG DHT marker */ + UINT8 bits[17]; /* bits[k] = # of symbols with codes of */ + /* length k bits; bits[0] is unused */ + UINT8 huffval[256]; /* The symbols, in order of incr code length */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JHUFF_TBL; + + +/* Basic info about one component (color channel). */ + +typedef struct { + /* These values are fixed over the whole image. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOF marker. */ + int component_id; /* identifier for this component (0..255) */ + int component_index; /* its index in SOF or cinfo->comp_info[] */ + int h_samp_factor; /* horizontal sampling factor (1..4) */ + int v_samp_factor; /* vertical sampling factor (1..4) */ + int quant_tbl_no; /* quantization table selector (0..3) */ + /* These values may vary between scans. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOS marker. */ + /* The decompressor output side may not use these variables. */ + int dc_tbl_no; /* DC entropy table selector (0..3) */ + int ac_tbl_no; /* AC entropy table selector (0..3) */ + + /* Remaining fields should be treated as private by applications. */ + + /* These values are computed during compression or decompression startup: */ + /* Component's size in DCT blocks. + * Any dummy blocks added to complete an MCU are not counted; therefore + * these values do not depend on whether a scan is interleaved or not. + */ + JDIMENSION width_in_blocks; + JDIMENSION height_in_blocks; + /* Size of a DCT block in samples. Always DCTSIZE for compression. + * For decompression this is the size of the output from one DCT block, + * reflecting any scaling we choose to apply during the IDCT step. + * Values of 1,2,4,8 are likely to be supported. Note that different + * components may receive different IDCT scalings. + */ + int DCT_scaled_size; + /* The downsampled dimensions are the component's actual, unpadded number + * of samples at the main buffer (preprocessing/compression interface), thus + * downsampled_width = ceil(image_width * Hi/Hmax) + * and similarly for height. For decompression, IDCT scaling is included, so + * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE) + */ + JDIMENSION downsampled_width; /* actual width in samples */ + JDIMENSION downsampled_height; /* actual height in samples */ + /* This flag is used only for decompression. In cases where some of the + * components will be ignored (eg grayscale output from YCbCr image), + * we can skip most computations for the unused components. + */ + boolean component_needed; /* do we need the value of this component? */ + + /* These values are computed before starting a scan of the component. */ + /* The decompressor output side may not use these variables. */ + int MCU_width; /* number of blocks per MCU, horizontally */ + int MCU_height; /* number of blocks per MCU, vertically */ + int MCU_blocks; /* MCU_width * MCU_height */ + int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_scaled_size */ + int last_col_width; /* # of non-dummy blocks across in last MCU */ + int last_row_height; /* # of non-dummy blocks down in last MCU */ + + /* Saved quantization table for component; NULL if none yet saved. + * See jdinput.c comments about the need for this information. + * This field is currently used only for decompression. + */ + JQUANT_TBL * quant_table; + + /* Private per-component storage for DCT or IDCT subsystem. */ + void * dct_table; +} jpeg_component_info; + + +/* The script for encoding a multiple-scan file is an array of these: */ + +typedef struct { + int comps_in_scan; /* number of components encoded in this scan */ + int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */ + int Ss, Se; /* progressive JPEG spectral selection parms */ + int Ah, Al; /* progressive JPEG successive approx. parms */ +} jpeg_scan_info; + +/* The decompressor can save APPn and COM markers in a list of these: */ + +typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr; + +struct jpeg_marker_struct { + jpeg_saved_marker_ptr next; /* next in list, or NULL */ + UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */ + unsigned int original_length; /* # bytes of data in the file */ + unsigned int data_length; /* # bytes of data saved at data[] */ + JOCTET FAR * data; /* the data contained in the marker */ + /* the marker length word is not counted in data_length or original_length */ +}; + +/* Known color spaces. */ + +typedef enum { + JCS_UNKNOWN, /* error/unspecified */ + JCS_GRAYSCALE, /* monochrome */ + JCS_RGB, /* red/green/blue */ + JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */ + JCS_CMYK, /* C/M/Y/K */ + JCS_YCCK /* Y/Cb/Cr/K */ +} J_COLOR_SPACE; + +/* DCT/IDCT algorithm options. */ + +typedef enum { + JDCT_ISLOW, /* slow but accurate integer algorithm */ + JDCT_IFAST, /* faster, less accurate integer method */ + JDCT_FLOAT /* floating-point: accurate, fast on fast HW */ +} J_DCT_METHOD; + +#ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */ +#define JDCT_DEFAULT JDCT_ISLOW +#endif +#ifndef JDCT_FASTEST /* may be overridden in jconfig.h */ +#define JDCT_FASTEST JDCT_IFAST +#endif + +/* Dithering options for decompression. */ + +typedef enum { + JDITHER_NONE, /* no dithering */ + JDITHER_ORDERED, /* simple ordered dither */ + JDITHER_FS /* Floyd-Steinberg error diffusion dither */ +} J_DITHER_MODE; + + +/* Common fields between JPEG compression and decompression master structs. */ + +#define jpeg_common_fields \ + struct jpeg_error_mgr * err; /* Error handler module */\ + struct jpeg_memory_mgr * mem; /* Memory manager module */\ + struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\ + void * client_data; /* Available for use by application */\ + boolean is_decompressor; /* So common code can tell which is which */\ + int global_state /* For checking call sequence validity */ + +/* Routines that are to be used by both halves of the library are declared + * to receive a pointer to this structure. There are no actual instances of + * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct. + */ +struct jpeg_common_struct { + jpeg_common_fields; /* Fields common to both master struct types */ + /* Additional fields follow in an actual jpeg_compress_struct or + * jpeg_decompress_struct. All three structs must agree on these + * initial fields! (This would be a lot cleaner in C++.) + */ +}; + +typedef struct jpeg_common_struct * j_common_ptr; +typedef struct jpeg_compress_struct * j_compress_ptr; +typedef struct jpeg_decompress_struct * j_decompress_ptr; + + +/* Master record for a compression instance */ + +struct jpeg_compress_struct { + jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */ + + /* Destination for compressed data */ + struct jpeg_destination_mgr * dest; + + /* Description of source image --- these fields must be filled in by + * outer application before starting compression. in_color_space must + * be correct before you can even call jpeg_set_defaults(). + */ + + JDIMENSION image_width; /* input image width */ + JDIMENSION image_height; /* input image height */ + int input_components; /* # of color components in input image */ + J_COLOR_SPACE in_color_space; /* colorspace of input image */ + + double input_gamma; /* image gamma of input image */ + + /* Compression parameters --- these fields must be set before calling + * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to + * initialize everything to reasonable defaults, then changing anything + * the application specifically wants to change. That way you won't get + * burnt when new parameters are added. Also note that there are several + * helper routines to simplify changing parameters. + */ + + int data_precision; /* bits of precision in image data */ + + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + jpeg_component_info * comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + + JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; + /* ptrs to coefficient quantization tables, or NULL if not defined */ + + JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + int num_scans; /* # of entries in scan_info array */ + const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */ + /* The default value of scan_info is NULL, which causes a single-scan + * sequential JPEG file to be emitted. To create a multi-scan file, + * set num_scans and scan_info to point to an array of scan definitions. + */ + + boolean raw_data_in; /* TRUE=caller supplies downsampled data */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + boolean optimize_coding; /* TRUE=optimize entropy encoding parms */ + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ + int smoothing_factor; /* 1..100, or 0 for no input smoothing */ + J_DCT_METHOD dct_method; /* DCT algorithm selector */ + + /* The restart interval can be specified in absolute MCUs by setting + * restart_interval, or in MCU rows by setting restart_in_rows + * (in which case the correct restart_interval will be figured + * for each scan). + */ + unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */ + int restart_in_rows; /* if > 0, MCU rows per restart interval */ + + /* Parameters controlling emission of special markers. */ + + boolean write_JFIF_header; /* should a JFIF marker be written? */ + UINT8 JFIF_major_version; /* What to write for the JFIF version number */ + UINT8 JFIF_minor_version; + /* These three values are not used by the JPEG code, merely copied */ + /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */ + /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */ + /* ratio is defined by X_density/Y_density even when density_unit=0. */ + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean write_Adobe_marker; /* should an Adobe marker be written? */ + + /* State variable: index of next scanline to be written to + * jpeg_write_scanlines(). Application may use this to control its + * processing loop, e.g., "while (next_scanline < image_height)". + */ + + JDIMENSION next_scanline; /* 0 .. image_height-1 */ + + /* Remaining fields are known throughout compressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during compression startup + */ + boolean progressive_mode; /* TRUE if scan script uses progressive mode */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + + JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */ + /* The coefficient controller receives data in units of MCU rows as defined + * for fully interleaved scans (whether the JPEG file is interleaved or not). + * There are v_samp_factor * DCTSIZE sample rows of each component in an + * "iMCU" (interleaved MCU) row. + */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[C_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + + /* + * Links to compression subobjects (methods and private variables of modules) + */ + struct jpeg_comp_master * master; + struct jpeg_c_main_controller * main; + struct jpeg_c_prep_controller * prep; + struct jpeg_c_coef_controller * coef; + struct jpeg_marker_writer * marker; + struct jpeg_color_converter * cconvert; + struct jpeg_downsampler * downsample; + struct jpeg_forward_dct * fdct; + struct jpeg_entropy_encoder * entropy; + jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */ + int script_space_size; +}; + + +/* Master record for a decompression instance */ + +struct jpeg_decompress_struct { + jpeg_common_fields; /* Fields shared with jpeg_compress_struct */ + + /* Source of compressed data */ + struct jpeg_source_mgr * src; + + /* Basic description of image --- filled in by jpeg_read_header(). */ + /* Application may inspect these values to decide how to process image. */ + + JDIMENSION image_width; /* nominal image width (from SOF marker) */ + JDIMENSION image_height; /* nominal image height */ + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + /* Decompression processing parameters --- these fields must be set before + * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes + * them to default values. + */ + + J_COLOR_SPACE out_color_space; /* colorspace for output */ + + unsigned int scale_num, scale_denom; /* fraction by which to scale image */ + + double output_gamma; /* image gamma wanted in output */ + + boolean buffered_image; /* TRUE=multiple output passes */ + boolean raw_data_out; /* TRUE=downsampled data wanted */ + + J_DCT_METHOD dct_method; /* IDCT algorithm selector */ + boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */ + boolean do_block_smoothing; /* TRUE=apply interblock smoothing */ + + boolean quantize_colors; /* TRUE=colormapped output wanted */ + /* the following are ignored if not quantize_colors: */ + J_DITHER_MODE dither_mode; /* type of color dithering to use */ + boolean two_pass_quantize; /* TRUE=use two-pass color quantization */ + int desired_number_of_colors; /* max # colors to use in created colormap */ + /* these are significant only in buffered-image mode: */ + boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */ + boolean enable_external_quant;/* enable future use of external colormap */ + boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */ + + /* Description of actual output image that will be returned to application. + * These fields are computed by jpeg_start_decompress(). + * You can also use jpeg_calc_output_dimensions() to determine these values + * in advance of calling jpeg_start_decompress(). + */ + + JDIMENSION output_width; /* scaled image width */ + JDIMENSION output_height; /* scaled image height */ + int out_color_components; /* # of color components in out_color_space */ + int output_components; /* # of color components returned */ + /* output_components is 1 (a colormap index) when quantizing colors; + * otherwise it equals out_color_components. + */ + int rec_outbuf_height; /* min recommended height of scanline buffer */ + /* If the buffer passed to jpeg_read_scanlines() is less than this many rows + * high, space and time will be wasted due to unnecessary data copying. + * Usually rec_outbuf_height will be 1 or 2, at most 4. + */ + + /* When quantizing colors, the output colormap is described by these fields. + * The application can supply a colormap by setting colormap non-NULL before + * calling jpeg_start_decompress; otherwise a colormap is created during + * jpeg_start_decompress or jpeg_start_output. + * The map has out_color_components rows and actual_number_of_colors columns. + */ + int actual_number_of_colors; /* number of entries in use */ + JSAMPARRAY colormap; /* The color map as a 2-D pixel array */ + + /* State variables: these variables indicate the progress of decompression. + * The application may examine these but must not modify them. + */ + + /* Row index of next scanline to be read from jpeg_read_scanlines(). + * Application may use this to control its processing loop, e.g., + * "while (output_scanline < output_height)". + */ + JDIMENSION output_scanline; /* 0 .. output_height-1 */ + + /* Current input scan number and number of iMCU rows completed in scan. + * These indicate the progress of the decompressor input side. + */ + int input_scan_number; /* Number of SOS markers seen so far */ + JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */ + + /* The "output scan number" is the notional scan being displayed by the + * output side. The decompressor will not allow output scan/row number + * to get ahead of input scan/row, but it can fall arbitrarily far behind. + */ + int output_scan_number; /* Nominal scan number being displayed */ + JDIMENSION output_iMCU_row; /* Number of iMCU rows read */ + + /* Current progression status. coef_bits[c][i] indicates the precision + * with which component c's DCT coefficient i (in zigzag order) is known. + * It is -1 when no data has yet been received, otherwise it is the point + * transform (shift) value for the most recent scan of the coefficient + * (thus, 0 at completion of the progression). + * This pointer is NULL when reading a non-progressive file. + */ + int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */ + + /* Internal JPEG parameters --- the application usually need not look at + * these fields. Note that the decompressor output side may not use + * any parameters that can change between scans. + */ + + /* Quantization and Huffman tables are carried forward across input + * datastreams when processing abbreviated JPEG datastreams. + */ + + JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; + /* ptrs to coefficient quantization tables, or NULL if not defined */ + + JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + /* These parameters are never carried across datastreams, since they + * are given in SOF/SOS markers or defined to be reset by SOI. + */ + + int data_precision; /* bits of precision in image data */ + + jpeg_component_info * comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + + boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */ + + /* These fields record data obtained from optional markers recognized by + * the JPEG library. + */ + boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */ + /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */ + UINT8 JFIF_major_version; /* JFIF version number */ + UINT8 JFIF_minor_version; + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */ + UINT8 Adobe_transform; /* Color transform code from Adobe marker */ + + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ + + /* Aside from the specific data retained from APPn markers known to the + * library, the uninterpreted contents of any or all APPn and COM markers + * can be saved in a list for examination by the application. + */ + jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */ + + /* Remaining fields are known throughout decompressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during decompression startup + */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + + int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */ + + JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */ + /* The coefficient controller's input and output progress is measured in + * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows + * in fully interleaved JPEG scans, but are used whether the scan is + * interleaved or not. We define an iMCU row as v_samp_factor DCT block + * rows of each component. Therefore, the IDCT output contains + * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row. + */ + + JSAMPLE * sample_range_limit; /* table for fast range-limiting */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + * Note that the decompressor output side must not use these fields. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[D_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + + /* This field is shared between entropy decoder and marker parser. + * It is either zero or the code of a JPEG marker that has been + * read from the data source, but has not yet been processed. + */ + int unread_marker; + + /* + * Links to decompression subobjects (methods, private variables of modules) + */ + struct jpeg_decomp_master * master; + struct jpeg_d_main_controller * main; + struct jpeg_d_coef_controller * coef; + struct jpeg_d_post_controller * post; + struct jpeg_input_controller * inputctl; + struct jpeg_marker_reader * marker; + struct jpeg_entropy_decoder * entropy; + struct jpeg_inverse_dct * idct; + struct jpeg_upsampler * upsample; + struct jpeg_color_deconverter * cconvert; + struct jpeg_color_quantizer * cquantize; +}; + + +/* "Object" declarations for JPEG modules that may be supplied or called + * directly by the surrounding application. + * As with all objects in the JPEG library, these structs only define the + * publicly visible methods and state variables of a module. Additional + * private fields may exist after the public ones. + */ + + +/* Error handler object */ + +struct jpeg_error_mgr { + /* Error exit handler: does not return to caller */ + JMETHOD(void, error_exit, (j_common_ptr cinfo)); + /* Conditionally emit a trace or warning message */ + JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level)); + /* Routine that actually outputs a trace or error message */ + JMETHOD(void, output_message, (j_common_ptr cinfo)); + /* Format a message string for the most recent JPEG error or message */ + JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer)); +#define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */ + /* Reset error state variables at start of a new image */ + JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo)); + + /* The message ID code and any parameters are saved here. + * A message can have one string parameter or up to 8 int parameters. + */ + int msg_code; +#define JMSG_STR_PARM_MAX 80 + union { + int i[8]; + char s[JMSG_STR_PARM_MAX]; + } msg_parm; + + /* Standard state variables for error facility */ + + int trace_level; /* max msg_level that will be displayed */ + + /* For recoverable corrupt-data errors, we emit a warning message, + * but keep going unless emit_message chooses to abort. emit_message + * should count warnings in num_warnings. The surrounding application + * can check for bad data by seeing if num_warnings is nonzero at the + * end of processing. + */ + long num_warnings; /* number of corrupt-data warnings */ + + /* These fields point to the table(s) of error message strings. + * An application can change the table pointer to switch to a different + * message list (typically, to change the language in which errors are + * reported). Some applications may wish to add additional error codes + * that will be handled by the JPEG library error mechanism; the second + * table pointer is used for this purpose. + * + * First table includes all errors generated by JPEG library itself. + * Error code 0 is reserved for a "no such error string" message. + */ + const char * const * jpeg_message_table; /* Library errors */ + int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */ + /* Second table can be added by application (see cjpeg/djpeg for example). + * It contains strings numbered first_addon_message..last_addon_message. + */ + const char * const * addon_message_table; /* Non-library errors */ + int first_addon_message; /* code for first string in addon table */ + int last_addon_message; /* code for last string in addon table */ +}; + + +/* Progress monitor object */ + +struct jpeg_progress_mgr { + JMETHOD(void, progress_monitor, (j_common_ptr cinfo)); + + long pass_counter; /* work units completed in this pass */ + long pass_limit; /* total number of work units in this pass */ + int completed_passes; /* passes completed so far */ + int total_passes; /* total number of passes expected */ +}; + + +/* Data destination object for compression */ + +struct jpeg_destination_mgr { + JOCTET * next_output_byte; /* => next byte to write in buffer */ + size_t free_in_buffer; /* # of byte spaces remaining in buffer */ + + JMETHOD(void, init_destination, (j_compress_ptr cinfo)); + JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo)); + JMETHOD(void, term_destination, (j_compress_ptr cinfo)); +}; + + +/* Data source object for decompression */ + +struct jpeg_source_mgr { + const JOCTET * next_input_byte; /* => next byte to read from buffer */ + size_t bytes_in_buffer; /* # of bytes remaining in buffer */ + + JMETHOD(void, init_source, (j_decompress_ptr cinfo)); + JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo)); + JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes)); + JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired)); + JMETHOD(void, term_source, (j_decompress_ptr cinfo)); +}; + + +/* Memory manager object. + * Allocates "small" objects (a few K total), "large" objects (tens of K), + * and "really big" objects (virtual arrays with backing store if needed). + * The memory manager does not allow individual objects to be freed; rather, + * each created object is assigned to a pool, and whole pools can be freed + * at once. This is faster and more convenient than remembering exactly what + * to free, especially where malloc()/free() are not too speedy. + * NB: alloc routines never return NULL. They exit to error_exit if not + * successful. + */ + +#define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */ +#define JPOOL_IMAGE 1 /* lasts until done with image/datastream */ +#define JPOOL_NUMPOOLS 2 + +typedef struct jvirt_sarray_control * jvirt_sarray_ptr; +typedef struct jvirt_barray_control * jvirt_barray_ptr; + + +struct jpeg_memory_mgr { + /* Method pointers */ + JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id, + size_t sizeofobject)); + JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id, + size_t sizeofobject)); + JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id, + JDIMENSION samplesperrow, + JDIMENSION numrows)); + JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id, + JDIMENSION blocksperrow, + JDIMENSION numrows)); + JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo, + int pool_id, + boolean pre_zero, + JDIMENSION samplesperrow, + JDIMENSION numrows, + JDIMENSION maxaccess)); + JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo, + int pool_id, + boolean pre_zero, + JDIMENSION blocksperrow, + JDIMENSION numrows, + JDIMENSION maxaccess)); + JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo)); + JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo, + jvirt_sarray_ptr ptr, + JDIMENSION start_row, + JDIMENSION num_rows, + boolean writable)); + JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo, + jvirt_barray_ptr ptr, + JDIMENSION start_row, + JDIMENSION num_rows, + boolean writable)); + JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id)); + JMETHOD(void, self_destruct, (j_common_ptr cinfo)); + + /* Limit on memory allocation for this JPEG object. (Note that this is + * merely advisory, not a guaranteed maximum; it only affects the space + * used for virtual-array buffers.) May be changed by outer application + * after creating the JPEG object. + */ + long max_memory_to_use; + + /* Maximum allocation request accepted by alloc_large. */ + long max_alloc_chunk; +}; + + +/* Routine signature for application-supplied marker processing methods. + * Need not pass marker code since it is stored in cinfo->unread_marker. + */ +typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo)); + + +/* Declarations for routines called by application. + * The JPP macro hides prototype parameters from compilers that can't cope. + * Note JPP requires double parentheses. + */ + +#ifdef HAVE_PROTOTYPES +#define JPP(arglist) arglist +#else +#define JPP(arglist) () +#endif + + +/* Short forms of external names for systems with brain-damaged linkers. + * We shorten external names to be unique in the first six letters, which + * is good enough for all known systems. + * (If your compiler itself needs names to be unique in less than 15 + * characters, you are out of luck. Get a better compiler.) + */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jpeg_std_error jStdError +#define jpeg_CreateCompress jCreaCompress +#define jpeg_CreateDecompress jCreaDecompress +#define jpeg_destroy_compress jDestCompress +#define jpeg_destroy_decompress jDestDecompress +#define jpeg_stdio_dest jStdDest +#define jpeg_stdio_src jStdSrc +#define jpeg_set_defaults jSetDefaults +#define jpeg_set_colorspace jSetColorspace +#define jpeg_default_colorspace jDefColorspace +#define jpeg_set_quality jSetQuality +#define jpeg_set_linear_quality jSetLQuality +#define jpeg_add_quant_table jAddQuantTable +#define jpeg_quality_scaling jQualityScaling +#define jpeg_simple_progression jSimProgress +#define jpeg_suppress_tables jSuppressTables +#define jpeg_alloc_quant_table jAlcQTable +#define jpeg_alloc_huff_table jAlcHTable +#define jpeg_start_compress jStrtCompress +#define jpeg_write_scanlines jWrtScanlines +#define jpeg_finish_compress jFinCompress +#define jpeg_write_raw_data jWrtRawData +#define jpeg_write_marker jWrtMarker +#define jpeg_write_m_header jWrtMHeader +#define jpeg_write_m_byte jWrtMByte +#define jpeg_write_tables jWrtTables +#define jpeg_read_header jReadHeader +#define jpeg_start_decompress jStrtDecompress +#define jpeg_read_scanlines jReadScanlines +#define jpeg_finish_decompress jFinDecompress +#define jpeg_read_raw_data jReadRawData +#define jpeg_has_multiple_scans jHasMultScn +#define jpeg_start_output jStrtOutput +#define jpeg_finish_output jFinOutput +#define jpeg_input_complete jInComplete +#define jpeg_new_colormap jNewCMap +#define jpeg_consume_input jConsumeInput +#define jpeg_calc_output_dimensions jCalcDimensions +#define jpeg_save_markers jSaveMarkers +#define jpeg_set_marker_processor jSetMarker +#define jpeg_read_coefficients jReadCoefs +#define jpeg_write_coefficients jWrtCoefs +#define jpeg_copy_critical_parameters jCopyCrit +#define jpeg_abort_compress jAbrtCompress +#define jpeg_abort_decompress jAbrtDecompress +#define jpeg_abort jAbort +#define jpeg_destroy jDestroy +#define jpeg_resync_to_restart jResyncRestart +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + + +/* Default error-management setup */ +EXTERN(struct jpeg_error_mgr *) jpeg_std_error + JPP((struct jpeg_error_mgr * err)); + +/* Initialization of JPEG compression objects. + * jpeg_create_compress() and jpeg_create_decompress() are the exported + * names that applications should call. These expand to calls on + * jpeg_CreateCompress and jpeg_CreateDecompress with additional information + * passed for version mismatch checking. + * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx. + */ +#define jpeg_create_compress(cinfo) \ + jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \ + (size_t) sizeof(struct jpeg_compress_struct)) +#define jpeg_create_decompress(cinfo) \ + jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \ + (size_t) sizeof(struct jpeg_decompress_struct)) +EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo, + int version, size_t structsize)); +EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo, + int version, size_t structsize)); +/* Destruction of JPEG compression objects */ +EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo)); + +/* Standard data source and destination managers: stdio streams. */ +/* Caller is responsible for opening the file before and closing after. */ +EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile)); +EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile)); + +/* Default parameter setup for compression */ +EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo)); +/* Compression parameter setup aids */ +EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo, + J_COLOR_SPACE colorspace)); +EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality, + boolean force_baseline)); +EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo, + int scale_factor, + boolean force_baseline)); +EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl, + const unsigned int *basic_table, + int scale_factor, + boolean force_baseline)); +EXTERN(int) jpeg_quality_scaling JPP((int quality)); +EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo, + boolean suppress)); +EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo)); +EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo)); + +/* Main entry points for compression */ +EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo, + boolean write_all_tables)); +EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION num_lines)); +EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo)); + +/* Replaces jpeg_write_scanlines when writing raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo, + JSAMPIMAGE data, + JDIMENSION num_lines)); + +/* Write a special marker. See libjpeg.doc concerning safe usage. */ +EXTERN(void) jpeg_write_marker + JPP((j_compress_ptr cinfo, int marker, + const JOCTET * dataptr, unsigned int datalen)); +/* Same, but piecemeal. */ +EXTERN(void) jpeg_write_m_header + JPP((j_compress_ptr cinfo, int marker, unsigned int datalen)); +EXTERN(void) jpeg_write_m_byte + JPP((j_compress_ptr cinfo, int val)); + +/* Alternate compression function: just write an abbreviated table file */ +EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo)); + +/* Decompression startup: read start of JPEG datastream to see what's there */ +EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo, + boolean require_image)); +/* Return value is one of: */ +#define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */ +#define JPEG_HEADER_OK 1 /* Found valid image datastream */ +#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */ +/* If you pass require_image = TRUE (normal case), you need not check for + * a TABLES_ONLY return code; an abbreviated file will cause an error exit. + * JPEG_SUSPENDED is only possible if you use a data source module that can + * give a suspension return (the stdio source module doesn't). + */ + +/* Main entry points for decompression */ +EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo)); +EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION max_lines)); +EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo)); + +/* Replaces jpeg_read_scanlines when reading raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo, + JSAMPIMAGE data, + JDIMENSION max_lines)); + +/* Additional entry points for buffered-image mode. */ +EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo, + int scan_number)); +EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo)); +EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo)); +EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo)); +/* Return value is one of: */ +/* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */ +#define JPEG_REACHED_SOS 1 /* Reached start of new scan */ +#define JPEG_REACHED_EOI 2 /* Reached end of image */ +#define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */ +#define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */ + +/* Precalculate output dimensions for current decompression parameters. */ +EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo)); + +/* Control saving of COM and APPn markers into marker_list. */ +EXTERN(void) jpeg_save_markers + JPP((j_decompress_ptr cinfo, int marker_code, + unsigned int length_limit)); + +/* Install a special processing method for COM or APPn markers. */ +EXTERN(void) jpeg_set_marker_processor + JPP((j_decompress_ptr cinfo, int marker_code, + jpeg_marker_parser_method routine)); + +/* Read or write raw DCT coefficients --- useful for lossless transcoding. */ +EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo)); +EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo, + jvirt_barray_ptr * coef_arrays)); +EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo, + j_compress_ptr dstinfo)); + +/* If you choose to abort compression or decompression before completing + * jpeg_finish_(de)compress, then you need to clean up to release memory, + * temporary files, etc. You can just call jpeg_destroy_(de)compress + * if you're done with the JPEG object, but if you want to clean it up and + * reuse it, call this: + */ +EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo)); + +/* Generic versions of jpeg_abort and jpeg_destroy that work on either + * flavor of JPEG object. These may be more convenient in some places. + */ +EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo)); +EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo)); + +/* Default restart-marker-resync procedure for use by data source modules */ +EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo, + int desired)); + + +/* These marker codes are exported since applications and data source modules + * are likely to want to use them. + */ + +#define JPEG_RST0 0xD0 /* RST0 marker code */ +#define JPEG_EOI 0xD9 /* EOI marker code */ +#define JPEG_APP0 0xE0 /* APP0 marker code */ +#define JPEG_COM 0xFE /* COM marker code */ + + +/* If we have a brain-damaged compiler that emits warnings (or worse, errors) + * for structure definitions that are never filled in, keep it quiet by + * supplying dummy definitions for the various substructures. + */ + +#ifdef INCOMPLETE_TYPES_BROKEN +#ifndef JPEG_INTERNALS /* will be defined in jpegint.h */ +struct jvirt_sarray_control { long dummy; }; +struct jvirt_barray_control { long dummy; }; +struct jpeg_comp_master { long dummy; }; +struct jpeg_c_main_controller { long dummy; }; +struct jpeg_c_prep_controller { long dummy; }; +struct jpeg_c_coef_controller { long dummy; }; +struct jpeg_marker_writer { long dummy; }; +struct jpeg_color_converter { long dummy; }; +struct jpeg_downsampler { long dummy; }; +struct jpeg_forward_dct { long dummy; }; +struct jpeg_entropy_encoder { long dummy; }; +struct jpeg_decomp_master { long dummy; }; +struct jpeg_d_main_controller { long dummy; }; +struct jpeg_d_coef_controller { long dummy; }; +struct jpeg_d_post_controller { long dummy; }; +struct jpeg_input_controller { long dummy; }; +struct jpeg_marker_reader { long dummy; }; +struct jpeg_entropy_decoder { long dummy; }; +struct jpeg_inverse_dct { long dummy; }; +struct jpeg_upsampler { long dummy; }; +struct jpeg_color_deconverter { long dummy; }; +struct jpeg_color_quantizer { long dummy; }; +#endif /* JPEG_INTERNALS */ +#endif /* INCOMPLETE_TYPES_BROKEN */ + +#ifdef __cplusplus +} +#endif + +/* + * The JPEG library modules define JPEG_INTERNALS before including this file. + * The internal structure declarations are read only when that is true. + * Applications using the library should not include jpegint.h, but may wish + * to include jerror.h. + */ + +#ifdef JPEG_INTERNALS +#include "jpegint.h" /* fetch private declarations */ +#include "jerror.h" /* fetch error codes too */ +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* JPEGLIB_H */ diff --git a/source/lib/jpeglib.lib b/source/lib/jpeglib.lib new file mode 100644 index 0000000000000000000000000000000000000000..15601972e35862531039a972af52e9f38c0bc5e2 GIT binary patch literal 264186 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 vEy7r3bclj~3XL64=6C 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 UtiDKr*NQD1o zR!@}eehbF?l#F+{&`tK#kkcaRv3>%k`-GeY4)Gs;M>rqk_hm-WRS`$%Q$08$^enDc zqsBK0HiS!C8;lv)!n9DWCvqW&dNfOc>`+5uWdB5{I4aG~jhPDOpQ2(bO~3UcyE zsHb=AtJZgMUnbfTTf7UzDyEQt-3ZUCTu4s?8u2YQW1Z7LwOs9Hl>(<(qm)f6*4zu9 zV#BkLF~yp*;8S6n;Zv;H4xeJpd*C|*v2ayg3=XdvCn1!CN3W{mw4UthVc+Q!+sK(u z;HMpa%j`(wU8rNgF4WVl`b)3uFP-QwxgEPxwp?%+q#%{(HXF-ACoHJr9AUeQoVe*+ z$RNNEUb7pLwHufN%6Mf>0R$}04(-@JOTe)VRp(kZ*oAG>LW#QJVWf&cw*mPAJszXX z#x{=DzTi4zmP@sCPj|GXd%AN_Dn-sl_!Q~j(KwG{TTau?k}a6q@abCfdqp4v&T#!m zD(H$<*>c0AkNEaoc(U!9l&V5o_Tjxabg&n6dq%c+ycY#V%XWR5_i+HM4@{P4Fnd+IPM2kgWP_BY;aSJUfy2koQzOZi zc$5B-OE&2fk!)#%n$oKoWz~tz`Uso#`})=vqGy{x65{7wCv3P678&#eR)+pz37iET z=rUwaxNsFY*Fo6ko^4yvTSj4&Bh+gldsO#rZ+gqc30R?HEq=+a2mIn8lMDv)Og)-U zv@89^N5914pV0M|^Wl-V$RGZLJnZZWTvm8ulW+C_MEM0Ho4L+vz@U6U{POVeP|hRY%_w%(D>(vY z8foGhwhoT!E(7u#^fch1DYB=5o&|cE=KYczNkssfQb2?f_zU2%!}n4^9Hj6 zmkn0kBQRjTFHXw05BY9LmwArRo{P$UWH8z|xnjdE}~J_Se8 za-B5`f77&!WPdXjes;l5rIz3oZEW4S?-xF+f34f>eJ4EE@+QV~Pdln5;3#;Aol(Ri zcJOcEzRiO|pAEzboe%Kdj1 z5Bu*sWS26VH-By;R-@F5YeFRwW3rC`jA+dE$8{bG9%5=7-}G&VfhD|yGgww171qFy zXw~ydzo zN3K5DpXytug7462c{)I8C|5m1Dh5w)c{4EByiGQ8R@CE83{5vf<3wq!53lircakQc zhb+6W2E3s?M5zTQh+=oR;50*W)ZI__JkX5%dUpp(o{N22hV02lZwO%G&ttj zRHfju3HBSHQWVR3!`->>8*5yg?yhljy(FTmsHl?J_mME?r*`cj_&D_2WzWbF&#vu9 z7jR5T*{i3Z#&5KdJ;aNRXG0+dgQ)oA$zlXxwEyc5oA)6- zt+2-5@ITx*pi%?VRkLr(1n4YiO>~qc{wLKg?vSY@J`#=Gk~UULlll4X&_}s(NUqrF zB#iX2CW>PriAolPwOZu(0pDHk)jq8j_IS~Je8Ab@OIC##gwW*e3n$jz)jYbUWTxE@VTE7eW3q`C#a zn{ILLjHh)BA#|>On8~xrnAJ_RLxBXQ_5(|y0}xnBLA3d@W*N+H<25ScuE)oP^$1w9 zbn%)cOKVpx4%SYcQoF3KUP`ZN*@}`f^Rs!x1SW%5)-I|G)Gop&3bPX;PfCuwdSM_~ zzi_3xXEO;9snjpURg$-TI{{<)W2QX?rsC zkS|RbKd^k=)N)W#cbrqn$+`4WoSe?RWPH8~qyB?SyZh|lPCp&2b)l?-f%PB0rkbM( zfjq7j6fEmLM4vy)j!j}!0q6D~s@|TbJB_<5<(WS!I2)J!ufUgW0y6d0BcLWXlI2$)y zD*By?I!jZMO$CT&s{DD;6=t(LgiD353EwUS%x)8os8iuP2^c54HMl4~@aDgIKI7jf zH(#~1{)SULo-rHq>S|~MOt)b^`uM#l)^f_vvB2zo$tZD&YMV%lg}i8#KxAPP8L^N< z2ILEj8wmXDtwj+nP_D`NFSysb0P5G0xrQ$qX4YsLjz)7M|&Y(!~*Cz+6qr#SWDCwaE3NBzrG=m%^TP)U{wt zE>!byq~ruNE>2+0h}Ue9-OLrj`XOR!vyF??$WSqpLUT9JSda@p6gRNahi1f7zn>}@ zWpm_~yrpnlV>YuEw1uW=7Bz=;bhGuURTZ<;g&#AKuAL!i!o>^<2~`ZGvcRb+76a9o z(R;)0JMjm4H>0T4;-SKW6ABM@ODNrf$u;)>5m~DA@-K8e_(#r?xjLhG*(0`)UZTT? zC-qc(m14#GDzTO)@x5ZL8-F}vtw$8opqg9ca!G;AWLJx#HnGkou5*aIHsK8+EKg`J zy${M{>n-0#GWzZ;efR0KNYZVQn-7%6#MNIJOr6(cZJ=T(Qo|+4ncG{b(ptNwdj_VX1~d9(}q!mls*eTQd;U#`Gt_A zhV{1)sf|^o3wtB@1Jh_8aizCX+&G_a6dy=F%V1sSh20-ji_38$NJX%TD;>i9s1%16 zJpzCttYp{QB;||rmJ5Jc-+d;ioCiq)%8poW9Ej-UTAMs0vdJ?(QFIT8nWIlCswJGx(JUS}a|?F6-|=Vr%<6k~h!#hI&csA8DRd0+`UYICQ8Bu^9me zRT5JTjRP9ic9`ouz`8Gz zM^^CFqqqKsLKN`Nu_@qz08V)5yGKaMfFx+VAQWYMpwOMxhHq1B1k#X7AWatIMM(pS zzz~y363LyJEFA>n`tHFJ@O6H)o@hTCf77kc%WPSYC&e>f$uk@qIeyu+DUxT#NS={9 zE!deuC%qy^_UkyDB71uD(Q>qHhuMW{s03Bx1e?>S$_(vwqw3RwS>pNGrb1Lt357qr zkP`w}B7rE$6Vh^eP#1s)GgWA?d!=eo0Nd6l+x=wsHDmCIcs9PIYL2?TBv7 z=3Cy1V{VgSzJI?DT&k4;uR^@gZ1k+vfmT+T$Xgy@=9?=V${|wW`v@@6RZc2=Uq^f= znCUxYC^%*{6~4WI`K1Y$3f~L(@H$}bGgm_7>Qwl0&`gW_tb`I}bj;6O;JeC%;X7R_ zeBXs==~0T8;8Nx9e0+P_gpq)Fq{8<$;6C~Sd^aKf$$t{xD)8MVIRd86-vr>h4KPod zaGzHnuL9Y6xpExcCVYpkQ)la9+V= zf3PBSOLkgtX2Iko!7D|_etZgTbfg8Zc!IzMlja9=3z{EhysXehXWHiT3MO42^c6I- zqYHY(S3CeKnC%Y^E110@=qR}3X9y3ZP3Y{#UyUs_(Q$M#Rj8XA-OuAKFk0^B@Qe|r zxK(aLZsnMYSfV6H%*5RIS>h;s>E=vP;$7h|&!}U8=a_Aj%s;}9SP1pBF)Pe;Bp7zL zGBg^+7LQ`G)D-R99^oY=`Zp1unwY2UEE zUl`e(ZtX;@hS!Zr+#BV_X{gIQHR^8o!2+>|NkVs_#@|>T>ha@fZuKAaU8D3}$f7)u zN*n3c=VmK?6fx_FG2N!`qA7G;DWqFF`L9f^mZ5KswH)Xf>Z#!F#iLj-V=FFn+*W(t z&0~7~lCV7`OC+H^@Q|4zIy{mvc2VUws+LgcT{2M6DoU1!SB#S7vYuKx14B(M_>z@1 z-907TDAQ`Xx8vE*O+pA~rEa8S~*)+&W5H6LigOSp~C zp%c0W=E zm@(a*Uvq5`i08$=$uma$Hp>I-!O8ixuBw2~q^B+7FQ^Fw><3EbSt1YS*OUeBJ5X}1 zCGuVQJz5r6a;>^{PV6n}vE}c44!NufWXK#N3o^&Oha&F$od@w2NSA0LgXAC4wq4~i zf37Py7-h#cwnHTOACOaFQotoRvMxkA&O zmRd;RIFyn@-SVzHRH8C&W2NuU zc#e@i_HM-K*3N;?Cw(RGog;mf@Nu>2#!u5YpTU1P_8n0P3gsXUljo@28pxHK!IBfO zK-RG9Dt2r|Jdw5{P13G~FByCRM|qBNt*P-^Eucfo(2$sb z(-QGFHO|%05zTTNl9|w*pALM?&;Be7) zA3sG0tR448Iu`q>JPQI*U}(Q|1NYJ@gI%)n1nJAhlj048`my=2`=;`x)an`URD>EF(m4FJ?aY2BjyX}NA@AJHV>-V= z!WiQ?ESh(Ivq{H7E+x#q#E{$qgm9=OjB4}}h=5w(r8QYJd1;->>H<3~Vte#atu~(L zX$YZH;*!s|SHLbXIjvOU5|)rtff0|6`ZS)_^$4L;;u8Am`H+s~q7(ATM>OQVej!iv z3;B7!khl7Uoah%KXZSKSn$}q4Te)aRVZV?$Ng;__@?0e*(dozJid2OHyKm5UuB=-Hodi=VrIwel z*syZx;s7E?l>?SQaiDH>ZPHOZ^Nil&HA|Nb@F79}fw~70I9bKO46IwderY|5v}Ez; z9{iICq9U>w#>Hz^uBn$Q4#a|$aWttu1d4^rBZsv&1sARkzy?JuSe{u-435%h8PJ;) zRR} zH|G+F9DF`X*DjROwct3c1;8S714-BJQ^UFf;4_7E?QkEsfuw5>Ao^0Z5{ThTCC$;% zf1blW6pp+-pmYuGV4Mjf0r5zMZ#Jf?3r)#SDtxB_-;E~B7vXC{kG-9}He4!v7Xsfm z0kc0t!Liw<%HP|7`N)Jzg>NN#{gZ%Mu4WOk8%Tw(4KO=QxK#MK?7P>5Q8`SVzk5#8 zv|aeorNTD{`FqlYQIM(e4aLfFG*^#ssqj6BZ|9jX5)hA6=t636}~V%e%^iAwIfP_|C+l=Rz)g z;8Nkc2p{rH7zLRc-$E>>ZsL*(E)~8X;M=Vxj0D6ZRsP2KFqg-VE)~8;G>9Ufrad)Q zg2{DUDt!Ng!R{D-bgA%#`SCnRHSnV&Tq=Bb0_Fz^a0B%(MDPe;9x>+$pNH?KfO#PS zZXkSF$j{3r4D&~qDt}xqyYQn+Ro<`S+nIoQ(1f$&Jr%yAfI0C6_zoeyH4}NnkM8sO ztG@!qim`((RsLq;+b|PG0^*S>f7b!-#yRs1DjgU0ax6BNqu3Bn z;W!WUyAP=o!MSf@v7SHI2?^Hlo=NVB1UX$$_<+@Yxa|$RKgl`aqqrFG14#PX%cNPq zqn6-b)Tv`*=Sh4vYBJk*a%SGXleN&k(<+}1`5cVrfi?@CmIG~R{Ijg5&BnhPJa*|h zFv)4bk(X}Z(l|UT$BI`%9IBsCH)^#k{SuHln;|=X?2LaH&?KwPyUQuZ-v2jdu za4ipzpm5y)MV#EujtfE&YLc|R3FRLrOuAeHXlRVtAhA89fMAl-g6nysaDbTx7?J`o z4@F`0=yzjVC(|97kZz!TfaGv@*rLAouNjrw%*Q-gUyP?#v}nj%RPyQ=<7kX;t$Mt{u)o5 z4@FfPl{Q4CuGW-TP3kRg@jOzYxDIw$+LvQJd zldf?X)0_juYfOxHjb==93A-Y3rGq5C#z_)ax}qe$0XgnRVsk45=kA_0cSD@|RzE9S zp5{MLJd6i7T}FPbG1tZuV`O(yAQKITlK`ye*?3LiJRmi)(6BswvsBp5h(k2#Y;uAEhvAk2I+tNz&sIK5?3GjgzqhR`OE05_#A(NpV zNPv==sFRs6Ci4_Fk3G>AQk9Ae3F%baHddk8QPu*eo&|@5j$0ZAVe_VOlw?-PKuV+r zP%qjpE{Bsxaljv5Uf?*s zDBySTGVJb#-qvxJo~Jd}fGCQYs@-I!SspSI<-02+7DX^gDnInhyf)~AWkMHBZmdB7 z52~UZxK%9;1(l^w>`go@&oovqfSlrZV(H}pxIWZ6LRL>If1FxvYe8ecC-!Pj5dIp8 zAI)Bz0DiHJn`GieG%G_Mh!b|Rz&ir?pvo$b)UmkR7{(H-gKuUhbt8-3XLRdP`ir5G z1`F7Qn|?jL#wJ^>u|QMJ#Uq;w*IS&k;QAEVTqvqY$2sF{r1KpH=k7Pu9g_0YaXx~f z*tW?dZnm`^6X&3cy}{8i9#?4&6~XigokxFx21tG7bHsg-V5wqn!hLH-2`Na*ZOjhRwY>;P+yK!VB|p(Y)y`xoiq0HgUH2pkt`M z`y~vIp7t3%26P3pI zap?8 zI{74>N@5kRw+v;YnMpda%lfcmWP3$XevC+k$Dt8s;HQp@R zIkJVR4Ok3FJXw3Q2WH}0-xp_-NN7kUPTrcpwhrr zbZDjHut2mS5e6jzbB(m_V>42)orKl5y@I^9z7Ja-@dN_*NWA*)T%n`&lp~8`lsEtr z=b``6je3vJjY(cH3h})>wrZ(X7@0js=rdab01)k58I9oS!lAMgdiwG02-SkF>R4U1 z$RP1G`DYKmVtDbP&>ph|qKdp)pd6$iAx=-or{3~cGMJ>na~)Y`x!$L;KH#cA1J#-6 zEiXjj&?R8Vbpw?raz2VZ8iN2#F~-QHx7=0X zGz{l<=2PD~kNtrj+PFNeVM%zcgZ+pD1u?Ze(nZyAHcgk9d6JBHI@l1c0$hllTWsf{ zwv19Y%o`eIFzM*#N#;=)wQ7L@q{A?uCaLG(ty@rIw*(*L^mLM<%OLuT;dk;pzDvJ7 zhxtd%f^SDkJd$l=RbZTLthUL6^yHs+kOu3?t^ET}AAWZ2zfdye!>dNAmKp`@l1C|E z;B_FNn^P=+8IIg)ajOl(-9uD2b_tS>Gzc5uyzpjkukZRoPD-y`_>raf|Dxy;zc zg=FAjIS1T`9O}Eb@e6qHDjcbhxW#a`=A;AYb`#7TP^ARBIm6h|W!WU+SoKf{H_`hXpca4(7`o%yOE^Pal?$Hdf#4KTtMwRI`TRI)PAR zc-UQB_=etcOk&0Gb1gl?jd`38vZ_>^>$*e7?fRCV;G-n?kKmC6{~kOK&&{8nrnlb3 zu<4-q?S$G)inqdtE_+m!^R`W}&046Ruy`PnYjYZ?UM6LZPx>e35 z|4>u~UOVB`w`_s8DSuLMQ_}{^lHkov8`9PUZ))0LT@<{rX@hNPaH+n#EM4DS>L}ND z&mCH+?_NHrTHn24FxbcX62ieX#rCdua7(io9_sSY_Q4Tj98GU*bQtrTGHa9+B@w)K zLHkZ6zu=ky0t$Sc>bIffWfIg1<&@YGMV3Q0nFsNa4sm2(k^?_Q82;}t6w^s`vA~mA zURfZhP;zO)K z*@I7a&M_nEE#wjj%30-yxHCod=%LSsHw=9O+X3tcJdqK(hgy&6JNMB-(<>MSJYpYB zIbdjUtuMg1!5Iw>-Z{&n-Pl5j6QMlaEj(Ba;z;p$cXhlGBX_%Fl2queDp0Q zhCVxRP3Y+Gz$GFL{87T(4G~)i!)|HF9FZYMvB(v;?*?6JpF&rOgE)-l7av8((@2K+ zMVJR%R0!uX92Z)TVY;%$*2s%7+yd*V*{&*Oy#@$#c$H4>&mK0fnglJ$W@_$I44;~@ zT!Jhq-*os`cW!MSiz0nnV_)&AQIhi4ijQ&5lj5U(D-X5Wxov z!OrM9;+L{YGHFtbq+pzb%8Cmn+1F^+*AWNz!{E%3Z$pEk`xT!d;ox9#^L*sR9T_HC zZhH$h2IcthLE&%L*#Ybpf5qkLFeM!>aYOWiBY;4i2U=ze7^rjR_8Ns9vJ%^&8;E%l z4cT1nAZvuzxs7!$)D*x2+Mw86VQ@Kgkm%dl zYhuSGi~cTRD?DDmLv%P%Euf{t_$Gak;h_R3!HL266Fgy@A&@g14g^KBUL)yxZewxi zgk*2U+~`fg*cXZ+=qwlT+Ys@nWbB*3*w$_iJ85zyCQnd0U{Bgt)qwdMc<%*NR8dBQh?jDE!QZZ-&e2PJtIc^D2q+l^`in<(rdAAvx zNVR}PZPn*sGBZ6U7^7`FHJRz#!GL0J%toqXlCi+cX3t_phlr2p5M{Y{u+-tHme0`j zL(f?axRRgDK@3Ina@qK7FZz6RGqSA?qkZq$t}>}01!K@GU7vo`AzRl(RSbyf95`l( zIayE&urO7ksbUDC|u%7H-{OQaV>1QMeT8sk_rHn1m6K(GwzaHM-fL* zi<6NXaC8<^9yk^L=+qW8^axmYX;f3&_@Xw>4QI<6tA?^*QqHHQoipPz+gGqMY2>;S zGh0*m(|m&EXUzxGuXqjKz>D%=9w?DCy z{483emW$$FxL8bz#hnBb<1WUMhGoUqn(xM_ptKj6ZUmo9D1%U@ZCR-Mss^ODJQs(! zfe1uUOkTMJ*M^abGKBHONQfRBPCoFIme ziyb?DIPhQ+*n*ymj%y85tv6~+IU}Jl25qo|+ikY3Vpq8RMZg!x&LNm18`Kg6nBRws zG8hpw7a~@*pz4vW2QV6D%2l2+G1;vak?5=L6T9VXbS91YhJK%J%yhy2Za2qRRgsJ) zdqVt;Y6mZc-yAhuRAtAOmXQ4*X7jh=o4MMnHdc7m!Wdl!S9Z;xcH--%bZL|#QW^eg z4tkl;C+Rm&3s19z-bx?Dk`=xdxHNoC8uHTICEs5UoFA_2g(d6eee(T{z~1n*&l12N zmcr}EpuME4>@^nCqn4@02Cr)RHZ`Zf*cHg*gL_bVYaMc6PBRin4t;r9o}*W(&y?%b z#>uFLqeDm}P9qRUx-@MJiHE}~q!C6!n`kD5q1S%LeuNpb8;m>Ho3)ogB0CIHX=D4n z2=B&EPTTm`#3fIoM@Khx72^H)n)_xs=xNB#78CCt#(<#Orv9*n;f=yq&6qnsTzdUe z%uu3L?@3R~k7vNDHx_%rzdR{lOT9*Eg<>OPr_5?igV~w3&vmxX9cIjRt2z92-RB|( zSNwK)oPrE&*S>@&Im519iYJ?`U9!LOEy6pOM5+l;QG_mfh&}*6s0GU>ka39O9MH{K z6*}TBJZLVL8q>rXi8fS5e5-sq>DM2oxv&sW2>arloH;(2LpCKHxA)DAv4hlNpcVa`Q zyDI#Mk1gjjz2;`83~cFO*}LU@QRc+OX_Z4{V40vy)3A={%)Uo!g#Z6q!#}FuvHHRD zuUAZ8d&AN|?YcGG_eD;9_$BHjlf#pBlGRQ3iDw4}Nf_>X)2)7evNs9yGKQXt*#d46 z((N2S4u5ar9 zye53Fi6QHfw=hSDr(Q34<5V=^qmso1bszspVP;Z6Grd!}Gx0$a$Bo(oG;8LWE~Nh8 zIHs=;KaaqdkUeKgNMAzHXm{V;RHO2#~@U!EzT zvs$97*uTGJ$1E+1nL`%c8T~MyiO^)sXY|9&He|K@fC%7z{ipAsp+qsiqyo{-e0^#V zol76gqx)e#OTuu{cQ$;d9X~%3$NW1J^H~xzP8f}6z{^OOvE-Sf@t46zV<7R60)%{) z2$P2ZjVCT*FdTxl+Y&?a8L}`jWPA=nrX__;KuA_n2vO@vAw>OG{9N_8Y)J}X7FQ*Pi6NKf;;q=EhE<-)VyvcENMhehdMDTWS^a7UOb?ha zo+zaD=)J?s#+WgeGG?ryu5XB@EFL^O*9Bu83pi?h@U(THhXW3__DJ zpW6@fSP4TJA6-TL)XF&KGfm86fjN2f^aC~-^Voiv&yz4{uCli|Ymo6o95b!8)1B8Z z&*vjF8S{DlFkc{H4)KZKjXlp~#xYMdF<;ORGl2SFzMvoGaS|pvzd8TaXC97Yt~N1` z>xcQmewfEe%=L(&tcfmMxpK{7W$M&CKvavfLyLp;b%BjI4729Ox}{oiV$kxXi*GbP z6z7>p`WQQvhiMdIc}ypIG->IEg{xrqw07azwK+7*8haZLM4S`h+SsKu%v!hl1_I&i z(z=D~aa3v{b%OD7W8K=?^$Y9kl>MF6Fc1~{CJnd7-s+bw!Eczn~^?3#L>8oKNfUxNFhQ$u;< zCln}fo*Ht?Q$xFlVqJtPr5otfP#(E1(WN*ww73sks#8OM?*o@gi~JtU)^?dQHuB;? zTKJRk;YkxFn#EN3KE?cYC}#q2sqnpuZ>O0s5)hA6_}&BD$uGe7UBtJiM=`0tsqozo zxF<~5RQcn=ao<0QZ#?GDlklTUg>NE0Tn(6x!3qvzLCW&(1k6JwTq=C*P~_zq3Y~nW zD(~-s>%%X=w*eSF1Fl5-sX#o7{p9J1tKnJpf&l&j)1K-ELGD ziMIV97SB02X+LH`=vnGJJHyMJxZ6eFHBI}*$9sqhTYOG^*YU9PA0+N9ulu{|VnH$4C zAn}W4CRvGV4C?$<;t`er33@~`^NQV3AF}AsxA8$#KpH6G*LQu;daUsh5y^Tt>l5)jg0hi_ zmzO~ljRR=5QD787DZ&O7E3YN^E@SC}O8_v@ZccLu%2l}oLLtUT2B!~DkocCzf zCt;_^IvnfiwxcXrT<#E^5EC}uQN!qgOBt0#f+eMVa@FQ(qH2vxkAxT{E zLlUzp_gKL?f3^6jq%pKBKtt}l<7SL+;dAI&Cz5bO1rxNu*BDRyR1$Soz5oX~9}z{5 zq6E@rZMZ5;-}NH4l0nq4_fFFelXzFWn)Pxx@A0f(itO=5c80hZ_efUQFStq;Z3;FF=E%VhN2LofG&Q5Hz`2e4aoFld``^V1;sw~=IkPLnHF@RXD#skDIO;9Psvm-An!3~) z_e?1h9~^+_Y+9Pk2v>0fWaI)dvshGY%Qy2=>{M8h8L0Up%}~hFsk+?J0!!^5ldDv24ppdsAbJ+oBb z@9MdmFECf(;$cwr>;!c?? zk}QSo=3*FeMv<ehxMb@HVfKL|aU7q}>~&xK!#dTDkUHlUd~T6=b>2d;yrp(oIVd-%$v zEC*ydGCtk;_$e7FQQ$7KtQTO{g$xupk5_u1KENg2xR<0yU8@bBvOJwX&k-0?W`-Ui z;t;l-Yl@AUsYcC=_L>}{CJ(^M6OYUaU=HlsRd}*EcDcF3zQ?WIgeUn)&8ax_)1^s! z8cM*=ofEZdf>Fh>LY-ogDm1u&#;qAUSrEms=20k?8yhJ}hIg87f!Uz!kQ}knHVtHU zN|s1SOL3vjw1{1Kqum1fiv2*_IJr8!!5`{&2-ppR8MbKOfHPM5F7PZA(2gUN7jjGe zJj2SS4U1{$zHoA7wZGv28+bPtj#>EGwHxqcm#k`^a}~NY^8)!C`2W8mc0Txvi~Oob zVh*Fsbt+97YhuOwR zjn@~vmOzcCi58B+;ba3WY?;Z_P{QGt5nii=6U&0DS8v1(Dh@%Q&&`e<7lNV@Pxl0VT6AYHfv z-~SnlzqHqQAJz-s!b+cxe^RX$e~yp8G2z$>29hp(7a!gMjA5?0nblPIz73cMO}JF} z?m_&=O&EBkONFlr1Hm#525_nHO~kjgfZ1ijeO~^$0dx2Z@NqNyH-On;uF5|T-vfYo z%7pv8{Ot#fl^q`(;Zl`%7+}syfE%bjG7$d)z~m>urNTEEFmn>%2EsQ5_~rxV9utmz zOe%amfO)kKKD3N~RT}W`yE~?CHOx7kn!(>Ee%*^1a*1#Apn?)F)LE%D#+eB8KcFub zn>B^@bRy7!+bXGo#!A4qZ467&uzP~k!D-z_pG3r&9Q0ae`njDBgw$t=PQ&E>Yc;yjgWrdMFaUw=W7qdYlp*Y`}B2A6tqrm1R38hv?=k|B|fo(aZF6O+Pl3L7tM2$ zr&%Ldq^o@DTW`iPR-qSFzN8e4Hm+WTJeLg>A)bXE)wJgzF~H)awD(xM;J_pob@_H| z2Ph6=TaZ&zE3>e>I#@2$ zUGI~;Mq552iP=75M-e@f{9>cim{cq#`En0^{IM}F&zP5Q%queHO>I4dRrIUI>{93# z76Z1YO)kWchCGm;+gsS9YX5>n=8}n%SHZbnwq7utX?H`}G=?#TB$ClAgUXcTg(Q>4 zn3@;J8%B*b=GNH5d_c?t8PcOb9lQS%R+_n}cZiKpBle3)UVYcAqRwf|E@q*`Z}eTi zGdAWKbu5`G7RqbPo{F!3m+vp5n4*o?#i!Pu(D5NS)y}4;Cl#QzxA9yUX_lA7V~yv8 z&Xw`CZKO&_#)aPX=HDYHPTqoI!*Tf7U70X&a4nc-L9HYmr%9?7dtyF#G!AZR>>VNN zlM_A4e;lEo`tga!o8`P--xk7KWjMs6{#B5Q!1^jwjKsLmrWsmrmI%5+pIL7n5_qZ8T0Ius6t{?yhJv;hd}y3v z$iFI>SOU5#X!msorn_kfRa%)sj!d z#Z(rC$vZTR>cTGrKeq*)Z>bA~RAn)noufzIbxPQpZm#NyNUi7Nltj_t#^8tk16(HB zNyi=;+|89tJQ4>RIu%9P9ggNpiU2&);;&(vSWcnPN1RD{S9V=hGGpv!D#Yx6^V1!1%yUi5r?fN&4$|P>*OvYzj=9dnd@4(G zHX~xTUbzAaFi|=;o0v~!Y0kDmPMW>3qd1QFYbNG@-hwH+Bka`I1?q6UDHg#&+RE%> zo^)w_?YhMaS4TguTo_oqT-oMSx&T;gt6NUx)VNmJ<;0?RU2s)&yI=0xbB(P)6780n z20Rnvs)cbs&>>&S9se(_i!aF=pKudShTL_39%C1~8M=Yi#ZQyR65RmnVh*^GK5%l^ zy`GYSc;qH{Z)Lxc;EJ{4;>2!+pSTwP6mY*&J+`daRO_L1tYb&vM@NPlXnjR>sB=vi z35Z83d^6Ct=d*porNZ|%zHv=l%J~c&i=GPKe88+U;ZotFBJX+=hWO}G;rkolY<<>$ zed*^zOBfEAi#dmY&y5#ct71ORMn@?qym351Jm(E{TzgWIqbm^jt=wH7W(ySFx zfY{%uOBV%in7?8P4F{jva+g&?(vWS~XOY`jLLYv`_%-48xd8Z#d37&Lz4V^I??e24 zk6#yl&G_;Bm<8vkEYK&n9LMhi{NBQ^6Tc?FyqAd~`#VfU8bk8qtz6vg&%xg+@nb)) z_H8{@EuQvIg^veiVai4tNU`E{NFJhzp#~1ajudI?lxEY@GLBXm7$$!7*u4PYRxgeq zZ++}xzTo_@IEtM~H6@n_lBeXMiCWOD=H=Uwq@0&?9-aD$V6GOtk>L z^)qgS{KM7w(1Dhs9M(ifi=Th7*vic9%{_+maeIygt_!PBeUDc7EXvTU@7bC+UV{BN zoBO>zmcpM0-hD!5?&pW!Dm>mWN({w1O6Elo$;?Z*C6D;6y-2tzUkm;y_c;{}o5f8< zIlN-vL{`JrY@=aIDN2}Q{e=i@%{211MACa~TTrdNG&gqK)%Xi}O>WO*96Hr;ukCi^ z9aps+!5{5Oc62CR?wfm=BM{#c8D?(snxr+8s>FxV+;Ut$jEa6Wj=gft1e8@5xPY85d@Vb~`WQ zO`kj(Y$<#RmFI2zArbQ2_E8J7q#Hb13C1Z#eQOH>mvI9fHksaRylA_=d+L`nl>HtaswT;)&O@MDN%c<~eg!*5WZT-BxEUidw_HbY-fx#CV%Pz?wKq^$<$E1XkA0q6 zba1#~7iZHhU^B$E@|;&kjm5Y^KW!kDqUV$K)*s-FW^B&T!|%Xr(iVq^Jz|PSl;Rw* zdG zQWKR13vjo9qLH~+q4KPg5n`^vcV1Z5^EFNqp}X+jw85d_{4%+dTP00YS^4m)z0C*QAk8V6iev;mtOI&QU0g3wI@s^eRt)Ra+z zK54bxxt#@4#?&|_Jjq&NY-% z6Cx^DQ`}NSS;ExN9>(SMD9j-GK~Lbc&}Q5Ytrq&SvT8#6i?GmlpoQqIFJPJ$k`gLS z;0A98Zgmy4kSw~umifG~rUI7%SJN~`rkLf$TehgCnXFQTyS!AGQMYt?V#}khoiW0~Limn|y$*K>Df=Hq+xT)587yXxzPO#f;4IlZ5k?yp0PDk z3|?joHvzs&0A3fS=`ADhN8tW5hoVWpJn`a`e}X1oPoT+#$uy}XrKg&dj?v^rrfbqf z{F261-_Zj%SU)srGXu0yR5WRGZxa0H(55e4-17JdN-p)SmKjB}BSS+cbljng^20O^ z2IS9*^{t;^0(A6w1WEo$O%D(A@x?syFVmwFN%y12g{kR5dPm{2dLrp4QgC>@IECoj zQD)auU{8&P8}VazTm}WN!j57T0<8twb%!zMLq`ikIyA#k;ms^sj{bVYcI$redi)k_G)hJ zYWP&ocPo6H&e}CfH`#>j+V5gtF9GkV7&pMDV%!Ozig7P|D#nBG`DNU{#Nei(EvvXU z!x!&oeIN)2^)$^T`w`|eu1y!(vl6LC`!k$1-NOxriNO(}Jpq0Q4i4?vKo1m-?3mm( zz^l$0D-#Khkd(y7Y-~1O7oP5>Bsjd2Vra}XVFGWtCtPuR<{YZ5${ARA>aP5B-D3VdnZ~uRiMby5@{Kc_Hee>HAFxU3a7>}^AA2)zQ>#C`Xg)sRZ14d9u0TH3Lxs$Ug%IZRFOcG7J6UjP!wdzIf`t3X zNo%VmI-fgo(|fDq`MJSN%P#YiC=%stA{n#2A7-|5tL1Gxne(i}A9cksZ$b#2qaSAW z3CWlp{V;QFV6{Z&HX9xuR2s*8JJG@o0p?^e?ofm#V;<5EGdbRBiS{z{!sBYnJ9=!W+z1$)0_%)|R(X4h!7 zu>BBoByXKRj`?+j(7Av)InNZ=CS!I<%5Netyg`~pK z5?n4+U$-82K?N4A)M^vYTK$v9ua?!VTv@vaS3oU-;6)x+;xVLz>zm@*N3mm0OO`HP zvjno%#X&PKea>(x@hk;T}-#ZO8J6Z$xYv(-*#^Gf$kTmutgx3M)4HJ%8 zO(mWDGhjaJgAY{ySG8UKeK&aE7O+(}oZ|h~TJf`U?rwN`xPgzt^HKjYcC=iYj9 z-J<2s&fPn0XilT&p7N9HCatPibWizXlO|m>V$|fT7cH+?)HrwY)#nyImD%m?8~@4) zd#61%>D7WD)W0|E*rgf#J0irXEb_7jOupZpYhhPZG(Sj zj!hp-{L8}9N6N+@oA~^iYwmdHoxe?dAY?2c32PqZ5DX>$&xo z*}tE-;D`0Ut-SxGi8z}$ow{Pp11=bjWr_SW7vZT5KJuZJFaZC;&OaROZ?!G9~|Nq8{^pGpI*m}ytgYM|x*VZSUud7N`9v{bemyK-LLS$*j={V(xA!QgwPvYVJF?UXLJfWI zMjT7JDXfY)_>w_nYnKn%by6pyT!m&X#8T>0J$Ph8OIZ?+!ADn=h=9g1+gy~xg zAak#|t`<5VuI}xK{<-c-e5H8EE=^6HA$^PR7*u_djii9(#Mr6 zhhG@q0*i18WY@TqVa3|D=9tfjeI?7OuiuM>{Wuo(bS#WKtKj|^^Su}Q+8YZ?N7blw zX}Lhf$clxHkNIeji;Rfe$9xV9EmWDeYfkvcb9T)IpOVPB;X7T1d17JSn9mpU`QhV2 zj}ub54<_-+VT)Z@)JQ8QXo(At>J=5{vV*--52HZr#y%<+W-6TpjsC{s^2%^sS$J+X zZ?;a8*PS!Ui^`{!;fTx;M(eSHUwbLE-tXaQ2^&&&sfPOj=d$82Fe~+;=9Q z%-&GaOpdDm$u$aR1<9`e8l}?&xc*RYI1X!$0|{%CvG~}8A1KV3a>AN`uvQC6e=dCP z8%~F?1=N+U)cngeiZtgifxX6!S8_)v4HPTg>e+i?)R+=H0 zADAK0RYE+3Ly2;Pf%%OITpbCB-EC&*W1*lIPcC?Bw}%|J4{LKUNF5iZszL`vXK2QOdu95IQQT ze9_8}G*3=TsjM7D_{4<^S3{#=<?Mw*xT$l>j$TdFKM(!zRoZ<{BOWqL}3UVho4mVeh!%5 zm~hej{V|GrZM@@C>wQ>)+!>S`Q^#tlpk@%VixmfR%AMK7?lSmF@Xa;!%KV91L` ziBsT4r;HfPA)~}4v9IcYUd7}9|!vLd3-ukG_!Q#4j-PCqHaDm3nBe?V(S@yyikV~ z#cphi`LMr6(Xtd+>+Kwo%el*!&#l;EYp)gdd4)}l*Y=%?1t@II=2URtON3r349b?`nc zIJ1Gj2wBfTP^m>XzKqEkHvTag_je;-8ap`7SO;lmNWyWp3BqA-jaTd0M47)*ET6yO z7QDF1O#=p1Ea?;M6|2oH<=kU98b3ASFkiRJ1pyAq!*t>&BTHR+-qF&7sJg~pW>^EXVFTkvwtZhgPX`aV=> zu%9Y2MBas1lVc;G+lGrHde@)U;hfN3n$})wX?IY6qtjaWYJEgy|K~U&tagyuuhI?T zwcT)M;Ya?=1Yi;QGh57_uUOP@`xTce4s|IG^_d(BW&ri6yx`W`hoJJ*q3U8QbdSiO z$8ez8J6y~HLk>svm$G%*?1)l?D=ZKOA1@U{0lWw&$q#56?eoal_V#&Fi-*Jt8Z0Q-IuEp)0hX4= zF+l0i{!Ga#9CO%B4>HeQkAXj38Jfix>7suxke}p<0BL8odWA=>gT!%T54(#VIdqAV zObTIO<>a{S=5tIL46faTG$nF6{#pZLace@O-xe4h;Z2_woJ;3vD=u{sjycWD7F}{T zJ8Pfb!U;{*zCbxHp$UvGoSCV&lEZoDXw{OQ>2k(#l;RDheSA<)$r1*^;{E~i;}N`S zNAJV~nF>}$qqHGFMzJCa=RrYNa+Jsoh5LeoP4LLI{||HD0v}a%t$!vngb_w&&=E(C zI_g-0i6xK-NfUK|kVJ_PNJ6kc!Yh~{ufhyq4IwxQN0g>(B1Xv;$9b~y3_jV7$qEm$$=q=p z1E2EgJBZ0$GFwGH{U>59dNLO923!VWQjWj_&Eeu{0I@HN7>_h%j7mT^inNAE3_lev z78tNi72oOj{C93sNh9$gc6r6#wOTmwF$~%MSeG#c%8e9LK$ zeBPhNfcRFGwq&;=9j9Nl3+GkcGk0#)vb*LO zHV2KLxIeI>dKq@hi-R~Ui~PE4+3b77zCN0?VD6Ho_rR{7xVyh>$x2*AAe2BFc@Jn| z1#!_mG=-=mj>-h8=83hsvBefYaLA`a;(%^==IGD0&mNVNlZm|t0{7WN#Ch3=m&k@h z%|Up}s^x5NZ43DT^5-v`WdF>r~>$0pgS!x&XI!`BA5 z1LweZ1Il;gJn{7dPr8JB3Bjzs_v69UI*f!=O!u)*WA@r9XE0NIUj@FGb(nMEyB1t) zBsmv?S^365rjQ4i)nNDx>}s?2`vG8{*Wt|Yk^Xi8#x581U<&5=z66+2I-Ds!Jn#cX z#Ta7XBEqbEhXHe3hcobDAbxS@t8V|Qeu#|- z8G~0`$?$3!!uFfPIx&xc#}A<7+=)E&7{IKp*4Erlw6Y`{UdUVCPn(+6W!0wUWB*gE z*|N2IzjG^hWe^Eq zEq7|s>f0z$!0vqvHqf5%!e$CUQlmGzADqeGmezJBz^&Z7m&`Y9oHqPZuo#$BxMZzjiPwZL~ zd%QlQN?n>#nYnMKB-rib71%6hwX?>Q7{DVoBuSuU=&dt7w7WZZzb1MLjeffWjea|9 z8x$o*^3Vg!YOL-N7l?!$Lm--ioXE%|^WmIC%1lx+xKa|Em;Op-Yde3iPz=B&0)-VM z;dDX5*$~pbBu36hvTA50Z~dfjlb|NFlP-8+Z8Qrc2HN8dKmbF5&aHF8G}19% zvEl~=Df{ZL#=G8d;8CxdjQ91cFdepj4agw(K;3cn7DZcoZMlWnK;fxt1J(IKqI7%d zL!DqabGIcoTDFbC888)l#TX42df@}eCWfgUK7f{xzyv8qYIxsOJiF|$bmC?{v(;N; zXC zmwRm4VSsqZp2)?ZAr7Qr_rt*JCf>RqQ__XUS)e*-B9jn99c8&yJ|P`LnscL#)FWEX z0^^y)Dw@1<`W3BJ5M7IwL#o2nnjPOsN02UMa+-b4@Jy}*b^dVN9-ZQwDl~QbuUqD zBo)ESr+T}Mhyu3e89wI=tf-b^QBwwo@+`^@lwW^B!RGCb&?-mdH@x?_LaSVn-*Ecq z4y}U841tNm)%szmwJfyTvvw~zW$sEJYvSBE0u8?*-{+h;9h&!c=->+#e0#h8g)9}W zXfZwzq>jN*#QH01-*+JWJ4_bWI_>zSH9`c!9 zJ%D(Hn8O?HNRG06tXdqNY$5Z2e5K!P+U<0d2tYi3K^c;A}{3%u>t?t1vq8D@7Yu461_nPgGii z(mPjAC0=!-uYuJNEWx_bw+TOR!_cRwn|y3_99?LBJAhYdWg~cvV+L?7MCX!V0mHmB zSjaB(QT0u6iky|%)^@+aFjAFZ!_jyPawJJp!RA2C^vtK=NBnh zo}y78BF=qH>qL6~X5Pp1ICqVt2G*`rtuzG}m-;mz!?kVv1QtL3Qz>=F|165)@t=-z zw2`WBKU&DbDEwF?eeUIUpu>vjg)lo^O%$L9X8kA(3a~F?XN@N*+ z)0x4r@cP@iyX&qBkL~WdEKPqfDEh#P2PY2!TlRd=A~OJXoUqxE=VIph zl*n@~Qd85ohI~x)*Z+3L%muxkf~^BGUdfENi;Ned39^uB1Ac{V7iq7dAn9qlxe$q# zK~}x#U|k=o&g^8>T}E^N2uZTJi_-R@@_uWl$P+_oRoLC2bu!<-*o}O<&6=DKdNnzl zn;FPj!vVBxZjy=;oGWTw=UXVN+#xDFD^lS;XUtqs**s)kT!M&aa(I*PNhD5z&*n|O z@5{$CFnRg`QiclWp+rR(lm6`uc!)#4bo?*G|2(`t4YZo4P4HQYaa{|mKCDvn!DP!Y zSU6}fIGpSL#(P`&*b5y9J9y++#>E^)B3|VTSLWP!vxE=_gjgWX^WY=HMtsmw9LvdL z26$?=bK`G5#eHO`z*w?pz`gZ&@nYwAJHOSLOP!71L<9~6aP4&ulW=TZzaU&*6zX)Km)yE7JKPL@ zIbaPtZqq7llVMcZts4`V^r=?i!c<){*|_{^FVV)i7g&T&A^IU*<@qy=tMis_2&#mz zx?I2x^PqR#bx&4>?0307;MZahbNZSoE8k7F5Ye-BopkYMl%b63!zznCS{9TP=cFRO`sTbW7d#1uR zikJTPW5>s-VRD38E!=#wq>(MvX!F>-Ncr)3nc1&mD=~zx z{>9&-dC3uEoI=H7rrb6jv)P#wcX$kMkG`cTiuq2N*rzimZb=xfx^5eqz-XVlWMZGr zoVf62SoYz!v2`#ouab$lhU)Fnr(})st>Ns|r{WyQLVilB``gIi52BdY>6oQyY5v%v zrzprvHsIDs3P%>h?np|{e&<+>FOQkGLXHde{Z+UA8CxTxrhm{e_r+V`Z9qo)yZylK z(^1SH=$J2w)awExQ;`x&V?zKNUkmBKkUJg2^41;W%Byg^75PmgwYnuPo>eVcio0UV ztClRTmI|v2zFxg-N!9$>xB@mWxM&fbgGqB;!hlteUoi;eH%ED6-muh){hfgp-s zKB$sV^5|_2Jd)ili}v|0!^so4CBZQKIY)gKF=1Z7^McTl3!xc`ZCl@4Tb8h4#OH#b27r2;hPSayJO%I;TwVXgMj&u7&tS0&j6-1 z1}+gkmS?{XgQy5*_-Jh7$T{#W0fs*Vrc9s1IE9$uTL+lUI-JpdpocH+^as}BV1cV| zYM@wZ*|Z{0#~7cbovkU>Q}|{D8OVDgD^*AZAz_>7Evey&Kjg~C2ol=kYHD3MrU6n5 znBBM(>QCuN#rn@K%);12(${5D5$xws{x{Xzk<<+_Ux(jv7>hw+hLu)+3v5;DppF6` z46szTb6GnG|8f;T(qu4}uv~9p35(sPo$>}3ZE)S|slOt3rLBH&+DcogUN{>P*8I&f zde}<%r=H%Pg4g(}L`wQ(ND^sMX5T-t#u(RV`pub8y+;YA>Uv|T!j>r)pQl8#s4&T$ z#58zw@xVw#6)nABd(r7*t3-?o0lA1oL@Yh|ouqdomz-bp($OHSORk>%?I?Na!wHk8x5r|D zPvWO7Gj$~r2Fdl7KjFbVxNL5Y-8@_cjQ)iPHbw-yquL0a~s8`dN`8mDzkuQ^Z`JD)Wj3kG`duWH=9@1qg)T;pMkG%-b1avuz6)ZZXCf4O5f&{(EGv!8g!I9A%5mg4EEP5 zw54vX~MOnx)8$Z8hhF&+B6$%|1X5#|9BeC zW74MC@xu!t63=9OV5lkL0X35;9_A^JSAtqkSWl=mrvU1s6?wJDj%RM`E43%Uww2m_ zlffFoKN-diMBABxYASKop139#3JQ%gP#;TG{im^yN*56LrhN|nVmolvV^d*(^>fmYJ037MPT{zoJ2KP#^N{cL}4 zeEa)ZNtWEa{lg1~C8eRW+Rh}YHLZZfXQ*V5=xdA0d zXY{!j1g)@C?1S19?2)ur@Eg65rZCS>oa!S_A~Vqur`haC?bRO#*b#UT-gJX_tJ?{` zkZm73)m5|9rCznjbxK=`WAU7{(^?Vu_K37! zYfBy4am{Z1dm7Gj!Kt*RJZHjrkBv!oB#HC$uww{#JvrHj*1xMuPswQ7ugRGAlU-PU z$pKfp?|Ed^cG@1!8k}|j{KBJ_AivAhjBwU)ZGY`S4Uf})UHj2QH1^&5<^ZzoGi2WO zvE7PefVAlQ@Pc_d?6?#@THTo{G-8Uf)KxZZ6_mZSr5Rw9dL>f8a`k$oqaHB&yv5RF*ieydlnN(y_lk8|sij11b=48jjb;(k{T2g|V7#)HdeV#s1i*TSD5Iw`1 zELB(KYpbTIC3#`DlY})xomLi38ARGz$ePSzu@}mk)X195V^WPtO{PU_Qe)J_gt(T@ zQcISewI(DiL1L!VmG(y!rCT*mEkVHp{Te`_;QU^=LESIUpKyK1k5NQ3lG3yy9C0G5 zt!mYtX+T8pK+MBpJk2u36VJLphJIOPL79G&Dz`?f>_119ACOu0c}UIDn!k_2tE;@) zsy*n(XBzpd}9p&UAm0*1&MRb)u&Qi}d&R&kz>YU@uu0Ft0oRvV& z%Kp@%8m;*!tPuGiYqe3-DpgzcE4Ad9KH%P0A7Q0q$DAW(%oWSNN@o%oN+Le^t7xr? z&(&8B^#PXRthGAtVVAC!p!lp}sMRG@Q=LtZVcf|Tms_m3IH7a%`+sT0#WFGc*Q|xu zb8_jxV3S{cSaAuP5W}-ZWyJ1@&$;5tFzmH)#bp;eCl6f>+aE-wLhq*tbNS)1_QU>Dhy3otDLzJK zxer4J;IQ9y$p0x~c=+j|SuVufhy9L23L>_{%Ar{fL|ljcwnKh9VqV5(G3Gc7y`#ge zhi$&Yt$*Bocpo4B@h#$pY#QnLz-T7;5oEElGJ)=_hHW; zj~|}q0tEAOMKJOmx5&j4N%IIi%$aHLabtbla(LhGDSu^kypgylxn5|Gk^09rz_XDCe}_GyQ*@Y6v?@y%YS0{jG-@o@9~O53Pru z6mfP%LjzI|`HvzG^v2OcPx3c@phIRwJ7kt9rr&?a?-hmddk@X>Bi6?bX=R7_&#yxs z5e55~`o#ACtxsmK?Nbu>$s>=UWu5BR&@F#B6oUJ9@^&}=Vay9GfKupW#e*0RGN2xU z827Tt%9G%E^65_ylTUXeCZ7W2Ng5f%cLR+H^7q@T5Al1}mM8z4-wHV=xur!vyRakv zMGF&*GClY;%dbtRwiu4hNiS;Q%5qEd&v|Mg0|g2UgnDhUupP!?UtSe4h2fh*6_sB=VTZgOx6pp_kc^Z zUPuL=YNOk9oMw{sFyJ27VTn4?iSh)b|0iJn5d&w2?^D3gL?440zQuSp1Te;(TY{V6 z`z{{->>T(Yc2-^l%*Q$$zs&G?&=08`E(k{XzQ~gVp7+e_t3*nkP{a1nRBfq8KX@*| zO(vK`FYu_zodq_oy(-&TX%Yv6MVJ9eaC+^AdH-Ig*EbV^esnz)Z^s;6PxVx(L-Z_q zA4!vT7&cOpQ4+&+SN@WvN>#M&cF2ijBRg6|hd+ zg%icQR7(;!J;Zso7x{Dca0>-f@=Ui zfWawKdvNtw3S@aW;%5QoCoynlv&1&Qbi}|VniZjgtGuSe5I=(%zB@4lYB>xLSg%C* zhT*|-z&u7WMYFCv+{i(?~ewIVVU7< z<@+<>{&^03uK-^+V1C7cg>W`}Zvf`MW8f0iw;mPz05FROo*UmPz%<9eCBhd*fxZEl ztHqY~?ByE=Q9mNamKp>Qn(dhl#hz|!dowK)V(P7!qEG(3 zr|ro7XWik-s+o7T=Kv#{m^(~4>X}!PlFW%i>;uJZQfkGyLigsu-rfD29L+!V!3t!>3l^pk;w{&6dGiHbbnq+<^(R8`2Tmc9 zq2V4?yLM*^)DzN=;cebU@@MWt0dk~;M`z2^NQLk^tE<0pTb?(8Z5!}9PdmMtM{rko z5q^2}=eU-BqW&gim_?Nh+=frKwxjPZ(_WRA@toUIt-odUg$;D-IiL{$X$k%o^-2xf z20VI__pZ^NbRYC5p$@>-Z64Dd{4SDtPdPhm`zgzddrw)sb$q+9N9o*Hh0C2%gzaso zULS{^>~C^W(v(fPS~Mp66V^3AF2YhJ?oFp?EwTmcd?_W97bq2mpG)?a=GPxIpJKMI73L%&-(4z+OxtF{M;!^(i!% zY3-g8w%uCJtCON<&?ljK2QRgz5MTW?6g@TVx4bokHg?cZgYUNMZf)1BK&EY58n z>l@ZL4}8*m8CodxktNicM8lEq;1Zb&FSGYjPzo>m0_Fk6@D6!O-E*?}?CrymOSB$j z@}xzZehce5#90q|j&sM?!>f%KO~mS?T3e?8t;^afT~uWrA#KfcfHvLEmJpC=Z=edU z3P~HdiRvN^W@uTDXi2zmxr;+|#qB6Aud4f;+a{x4(=684o!jV+5;hd=)<0R_wEhyB zGR<^SmqOzVCt=MKHa(L-IzCHqKiW1GgPO~7H?N@Yw&$V*_`&N}b(*ZOtNlh~6|L|q z_{B-wrd%cHB^7a2IF-c{<|W|Aa4EWrSMu&>KWbGea1z;;Wc_F|zW06_wv8&6gK9mF zDsXPo(Dt_N1;vkT&HlEdHWWV}O;ZefFa;ACaxgw}AsRZ=@fk;*wikmaRhveCghg7` z20A^oYko&~K@uLI`l%db&TYf+mEqi$hA)qE+YR_~hij6Y+x!+pec@U}Z-Xl?=e7w+ zR&5Z0lvl(c9-Hc0ahuK#pj(C79!vJ2ebx1Qt`1B z202kXS9sIqELq#fuI6%B@f1S=Xbx+W^g&1X!!!!G8g=pScqo0^*u>>L#$o0 zv@5!;zt!H8q<8_^!Y3fmXcef+nr>^C^*!q+;k+f*lh%JYx4E2K;q6j175O%Pik2Fp zx0IhPB~6*)sG9?|)lP1PA0Uu)=SC%>29?@A0&NzhP_ApZL$E0q2?{0sl0vC5?GqH5 z3Qw|vLSe-sN};WwP&o7Z6m+U}#1QBUXdxx-<+isj;K<6{*LF0SRCxyrLp4EIs}S~K z$Z|VAgQ6BXly?ig=x|t-*g!3pROhx!o!hGDco!NMpE|dVaBdr~SUaq*;Tvp*E{xHf zS=M&6Gi)!Uy}{-YjJ_R1)CV}U5Bh7QXrF*DoqaZhBt=R(f-KXKWfn*7iVDfkWqp`Bz@@aQKkxFR3R@duC~e;#i_H0-`0_qE{d+Ds*P ziy$c|xdbmnfiKpfy5`{d4M1u=sH45oKDmmtd_4&woy(4 z@t3_)EV70o*^YlHiIMV`&G^lZNmhPQ=mOGxj_{Q>TsiM{pJj>n>FcakE5F1uM&y@v6$Jj@tDozGF%(778fsgV_p=q zA%&w{CLXhyTqahsz)hsQ^h;{^&->R;k7AyP6b5PTl(D(|5TR%LaQMd8!ps2b_W{XT zEIko^KbqGHft75iXDzrFipP8*dMy4LFt?gk%PaUKX07bqYonOgBZZ+amr*%~5wqo| zEsLX=9}#$Y#@DmV7vV{Kna!@1lGzgThZ}3NqnMx3G56(KDMvVI>nlSWvBh8>48M|J zaJ1C32Pw&nFSEQv`X{8v_%f-Qw`ApFxt*q$!=UnqJddTwXrEws& zivw}L=ffcD^4hOg$0a5(!df$O#fUfTqV|`zIcp0?Y|r z9(Oi;P;OENljsr5@Lh=qR{$paf+(C>`NjffN(@}0`aTUbGXOJy>=uFZl^MQ~fEla9 z8Rh#zS7NzXf(2+rxh~wG1kIECVcmbv ztQ5CDIcK=}zE}nE+fWX?5OLvJ!lBtA7JwZ%ukZy?q3vMNouL!>ET4+qST+{Zc{$}s zI)o&w<;y~yu%mf$Y4<@y z{gw>N$}B*I_PB?w%y2ewt(qGmCTF-2pOoTZ1?)pqsb2&HSSY$Q0idnS%Kbo_Kv|MY zy8-DmH|kzJJY3L?A5rhuNCb$79=FS<$n88O3}_U{YU+-n6ttn}vSB$YWq7{2EuxMh z7Zo*_l$EQoNWozc(O_$aI&o2tI#I~PTA?%5zyjdVj;H-MQgz^=26TX5~~+-}j@ zP?qL+ftS6kCvqve%+OA)PJ=BjHUuP?GQ*T|_^+8fMZc*meADHAR`)iG!g{lsT!rt} zrI$YDTNlQoJh-(p3V9S|l2r2sY8|B?ax)Tgf8}BqzQpM#H$!f*8S={gfVPFSLm5l9 z<^)OQg>8No(TR;R9ny58EE(EG$TBPUHD_o$@MsgVw7c`tj;HO;J;q)AvShsA(vE5C z1SR=x<@9%w6~5PA5q3W~1y_x=2^nbq+=<@ceD0dioT)4jBy3_&0tuX3h@o;j>oP*G zbZZkyG;TObSzswIfnmmDgqE<}fx_y}2}|y&`rlFTfUHtMAF#0rA*HZZn_BlX6gR_? zYPmaW*xeZvA06Ka1R>g-YdTI;rCGV9dCo9bZgB;g6COtjc5CDEw0pC1PZ=dK$k(-c zXt+?2FS6y9m1J8HAzRsj5N-;x)r$qP75k^ux*xJAK&_6;LL25z$P1R@FuxcrzuBNy zZCv)`lJErkWNxDRTV$Or(Lp#|aLUGcJp9LDEvLYMqd!PRK*4{5h98 z?;8g?o(aJzUTc3I6_tch5l14Npg4#1SB3}@@rXF(--YnYVk_02Aa%g(qZsj9J7@|_ z*mImB{4Qw~`Pey!*5uJR9`EDuee8q};xp`6A?`PVONAZV7%j&rNDbd^52rs9YPaJD zJq^)^i&u;XSJ<`!miOGwt?LireTsmst&g6}(W-3P1Uq=9w9J_`MLSfgvxz+^O&`@~ zf(jg32jqR$z1lCs?hn(tAj5ELm#Znmw98aaXg5g1CU3pDEy2G4oa5b#CQXHK+d<}1 zrVg_nLqZBiTN@0y=82+7o&|}+Ol*8-vMIgo-$&V`7#b0UGcp-H=5En|QuvIGv0aQQ zyUBb45#s{CsFAv!E!-(kXbm%SbM#8@l~wKK`cG|Ae&&gsC3*GZ;g0uf z_AmsOFjZi*n)WbziY+&VjdzQ*W@s0^rNTWB29Jy0FJT~bNnTwiyckurXW|XkAz9er zVizVW6Y2r>l&ATDV4Ue(hxix0_bw78f;-qzg?pmA1<`hR(wDtA*O%xW zmuMdcOI*rtdcc|O8wOzrT*YC4Kw3$(56Q%XR2@bD z;=>HzbgZuL*7s9p_%6fyLBO=cz?tED1Tas?*QgQ9nK6N z)Vh^3fO(Eg1A*Mq4ByLuIi$mx;cEthw*j+&D)b1fjv2l~fH|hanc*wO`~LvUEfmfn zoUMFQ05eC2GsCwRI2HnC1SfWcv-QU$z*OmQX87*IgId6J$&IU6O_a*6*n@27K@)&%Fz@0+>~Oi#hrqX%|L9kkPAYitc( z2K!UmU>rhGQx(s#p&u;tjBQ$fIy;?YQzyEmPe*cR8RQy>Oo67TDuoV&tLX%g5djo- zZ@?qQUGPdNa%zAAgtJLO$5d#qh&|csf3g1I1uhEHehJ-%>!3dH`dmA1UpS3f$enJZ4zq(e7}RbRRG( zH`S{pLGIGKa^n@&?hYGP?QYa??I*+*EYzmDI+BzK&e6m<4GlK#d>YJ3loQxsFlmgf zB#Z5Ant(Mv6_a2gORY?Sl2AKxQaCj+BqBx#9&Yk@iSRzW=+&Fhxg6~n4hRqyBcw+>i zq?Z)@7J@6SARG4I*M;%BBD4FzslfF>a^O_(bf|j}w2jPYNQ1u>m~FP{l`L*SCD)>o zYr8Jfid$Goi>&0@XeFDv(Hs-AD-4@$cC8>!o9Nfx(8X<{r8^76au{ZY??RDe1y)63 z_anxl%ckcPCIgw9GV z6cRYuUW0$PIO~+v;|ZBvq?Jcvh$u$&Ec)*AOGu+^$3ZnG=)rk3RP*^6$Q%w@vhk%( zbZO-tSRjTIJ9ik7{S+AdgsQm80^!vJ3Qbc>R>k4MEH!dX+LGdG@S@sCR)a+ zO)a9om$&By`CFn8K(TC|E zMDi=oJdxW8(Ta4$d;cxO?`~pgAo76a|Gddf-9bC#0LMR;X|C0SPX6ijZtc~R2PmHD zN`AeY9smre-vBC9pRKIuZ{&BzSzi>M`9WKk4T@gc>nGoY%9Zs!(NP6iI!|k8MZGOu zSICZP{(vm)0j5Q}io9t5f$kkBpc1$as19_4uY59~{!&>TOiqFpA~O@XO52}dbW7y4 z7a5%wUqP)?OC?hQ-W2fnbZ~3>8lgpYdToM|+?$Y;L8H^7Bq5XW`sxzia559_E#(ORm6275%S{+sGTH|0Al3a$;u9VUW0$| zDO6sP%UzLJFcSMQV%JDGd~(T4_MD_#A&4mhaWH9VqkWP`TQ5mT`#CAeAfZBogm%Rb z_&D;R%bX`zl=?4|dB8B*LcTa_mpl%;bpTdKrA|9xDIDXQj$a^Mf&-?oFl*8^hZsT5U3GUTP2H=LPX38)^Llrv+oIMr`rrZxprokw`rp9$ znYBJo+n;$N^9aQ09xjKR_uqpIqUyc*8-2oGiCd0DFN=X;wMIWtz-uXMmg)3&wt@A4 z7+7MkMQ75`2^Zf9UX3Nd6@p7UcRHgNyX?j~00qT}pkX=}R7TG@*EEMtS?VwJS(lk)fT|l~pnyXUOoNCGUi>5Q;vYqLajN9SPelhfkYh%WtOqPP^Wgj(cM*u`@!b*2 z`l6irQpK!@qIeju!tW7n?7N&TJH&WhV?zzEmVBa;q2*xrj#wJw}~f zAMT*~3Vm+ZyDYk@nd-`Hm8(;XSIl){uwod)Z=9{N-3yE|zhQ_)M|&vfMMWCJ)iwdRN#HKS>QL*OLig3j^8 zq;!ooB43V8y(VY1Uw;t1L}(}090TdnK?Jr&4t2c0@d$Bn2?z$FM{;(ufq81?YiNO{qrJw4`b5f?|I!St?4=npQ85O#qf4-raQ;ihB^8s6 zZgXYQDGIwL1*b6PAddInOA{J!o>TGp&p1K-kOVKuSaH^||sw&m;e0gId2Ps@c z!50NSIRhpulkmxDB3XgG?&>hwhn(m|OV@Vt0rbJ`{>BFv{>R z7ilDXZhqiBOKOWQ6qQv4#b@s8sYkP~;N(5i5@ac|k62$Oxu=^wCbS4iVsjRQX)-;y+f? zk5A&I>1OthjScgn){=Le~ zK@*SJOgoYMn3!`aR^1)NoQf2NzMPQUi1&%P{3k!~Mls)n6b7lC7~2}$bH$h0Oc#+m zK=x(zgdoU`c`)22zre}8J$jHL%XrLYx`@Qg{&wyC9=MBv**IJ1i!S0qAY+*y{{DxM zJQG?08&_V*WK!7%uCDnG&LS%$N1TOfF}&V33Qpo$}?m%cGc4 zd=ah?m>K;Kn zUR+*0lQh?t=IMTX?pOB8{b~V2&Q8QxzgoXPntQpP*VV{9zFuDO7S|L;ajq7a7vLv- zl`M@M6;>~*#kpZ^U^$GI^J2Un7s<=-Su|(KLS9BE41~?q%c|$a0#q-Vvn(iXs{;Vm z$^)~P;ZU-A@!Tczs;d^w4OZokgDLc7xR@TBI3|)PuCL?DdvMw8g;h(I&7&8R__vo; z&#zq!joFw~yl$l8SuKi8Z!A?p8cxgW(WJX(2WqO98BauJcU3R0TCy}yy9gNuX3tp& z)FOTMLU>rIqCnk9mY!2$Q47FDv+u@vE8Mj#t6hP{2+TqINQGHZ0KK5ga1(#j=Q?S< zX=KhQuLwM89V|{-??nf4@xhSjr1eD(wAhf~r1cwk-qiyx(MjteP{wMIa5-5K0>8{o zLe}Hq!#W)4E73{eC&2X`z&u7_BLexnz$Xr_MUwdV3qJSgFh;6bzCRwIC_C`aV3uzu z9_$6oMow@DthyP#Cjs+}4rhk%2YB!cz*KQsL*OdH4Bxi_^J5*(3|~6le_n?nJ_a*< zZvpP_=fH<$g!0LG;+yZpW)=SoX64(8XAOWEPUeAdHaeIMn6K$@20oDR7iO`4?xNYt zVI!k&M`EFRud?EzP<@KB!aJ>)MkcD8H)sxa&?Bfodm zB}Y4{WuQ2>;^y^c7D;!-EX8?R#WA(;lyfW2-dcXohtScp?$aeW+N5{Y!cU!Bp^7OA zp!;-H3vF5fEBVuJqSW)E&D@T_5IMhr`EoofsXqQ9}CyX>G&1e z`4oSbR;)p<;hd2RId&=+Q0!E_$F(g#!SB$$Zr=KH1=B+JdTtF~Pjc&6_Zx!Ne+B(d z2ckr3Twcd+u=0KS_<#6(napP3fD%5@J z%1fcUdvWNLfAyfy=>aP*fTP%cp^pb(=nR1f!j6+2id`UAhzu}_a3IUULBrKJ47vqX zM5AD&3OF%R2jOI-`(T$BO8O2`-dbG@ip;Na8;hs2XYdUy# zq--Olej?j}^+(;|BwDjJyl6`Wr7B_h9fL!RfS6`R!Hhz5^tS}}kP_G<)m1K)F zLAovD&vbWZcIyNZ7?)F@S6>^R0Yz-Iu4Ku> z&okQvPrtt5#XM2opa~MbegrRP;pM97F|Si{$tg5h!6rmlu5>HUVXZ^%;8s42#IzQU z@KPLS=e`=4r>*0@0EQ>vS2}EaP_wJz5^v_doa}mUc;_*IhG7oi^1F|eSu67)gI2Gm zHgTsd*IsvAD{-rv#gRdgM{VI*gjSNGZl*v}^Lwk*bv&q;&WhRUeK7+YC)*s`;68F} zN4ZZyUgklZ-U+E#{gs*fq|8*S%(ot<8ncBu%xz`4Q}gP&R3UFvg|JcG$(*V>*Rc%T zl1R-3F5zS#cVsh=M`{8)Wtn2W%5ATJ5_$`3s*Ooe*PUWyvRB>wDI@ndv@vwBep0D$DU>t{kv#5=m*(#xROtUm~uX#%hPzZ-@JT5ZCpAP57uVTp0 z)LL4BuxVe_^!h6_(G|EqMV}Xl=AwNQb;*{Xmb(wwOYYjX9 zi%)|!p+dK%v(UwS8+NkkmEeHri}J7l3h%fWen8t?1g!8tCudw&XibU|bZRZdOr2~K zSI2GII`Ol}E~MbLjzWiW{CQy2HdE$~mmwa1O=}UD1``u5_qYVq{eX(*+_3W*QJ633 zH&cjDziPqkwU&IM8?4`0cWLXU@i(EI+t#rjdWHi^q9q>yb)PlxVzi|d?G`#}m5=g_@IVp+vF$!FqIF2bVF!R6-X>Eba(%OPIHS7{(5Ey2em|}rm8qQ@a z+ZpLB5M)9};gVh?V9=@q%0h7W#9*90r6Mj=oC45`;3-7K0@9G7w9j3bh(PTl^06?-1Q?p=a^HMH@D=5+A*J z#lg_-B(=iTWmT(OYE_C_<<8#1N9aX?!P=@8dZ<^WwLFDnb&~jTEu!p$WN|%!?U*dY z2B{*JjZZuN-QuKzJ4N=rqHGnP9K;S0qX7Bed06lbJ-_HztXLBBCPZO}&_vvD-q}?2 z20KLt(ae0Vcy%Eg7iKc_6nqgjUZiGrd_VyOp?@&d3GQO##kORS#|MmM@V=sLJFA7G zg_L>Gj$;^BMwwqi3WE!n;{~wX=*MGriT61f3Ui;e5I{mQ3}?$#3+C0XfN$p@j0EuK zirEWmapj}BYWdt{wM!v7{hS`3s~1+o@7VIWvll}!x@`8MYKTN2-CYVvs7Tav<=v3k zxMebb2_&QtpaOzoR3Y|cF=7R&Qm$eMI_Fl&-^R@n$U3uclCn$rc`oY!*`r73vQf%9 zQ-!Sa2bgo_vn>%4$vVqOi?P8()*0#nmq^xm6YyNZF%}cdWN^0w?yEX1yFHPtljWXw zp7{0y?#*-Hn+JUFo+rK{@B!Y)U@$8mm4fB~<_JeW0@m2h4WQ%6_S^%>}hcm;+^rv(f;$tww_d~$Fa1MOK@P0dB-q+zcxtQS_0G@QYoB>Vi zy8;EIlIpj}i4e}#e!Bs4P=_<#E>fUI~~RbvQG8T)>Xj zVOS3av;JKMxckn5FCXu31k7tX+}Y^muYmdN9QghTeD+Il(+B?yXKTOVIJCW$2e$}j z^?eJ^ZUf8>JiJBVa5t;(*8#IZhcm;+;%@@XQ!#L6_9_}{z0_bb3WBcz;X zr@uphIi|yzm9G@|{sEZr+=n2L6`GY#1I)K|I0N4od`)M?dP$|F@bDOs?*^n1_UDTEWEC$=?E2dT|s$VGYTL*j%zw0QXvvpX!r#ef4d+L zQF2zD5)W;@=-0tAh3I%ojSc-CQ*SA(jHx$p?IK=CWubyc6Ax}J zWo;l!G@kZ)+k5u&M-*-F^U4>($+g|AW!-&j+KvXsEi);161E`h?ae3{3BavDi%MZ< zxRs;$Qp2vn$N@LbtoSM|ui1kiqV4f4^F+AN`hty*x2>YF z(9f*DL(Ia@Z0i{cLyueFg*kXMJo93s!^HS>pV#=5^epbUv5lc6zQKL9CVS>wV_UvU zRqAe6eH*T`oT$$Qk_~0KgFi2Z+%t81XLf|x4wmT<1685IvU@fmCc6g_g{wP;B*iYe zg8DE06*0i{C*m1{@eg@SIj$f4T|Y}K$U~QfXZY;`tB_Wn`v{gzHZfasN&fRn_jyscR_T?Ms7#UH zKr%H?Z+3~{Ts*8kA9o%q^PDX|LPc1JOFz%+8zwDg?wdqug#sk$d*my-1V26^g_VQMf{uL0Vu>#}CTUDnJ=;A}-r+ z%e#n*-n$|>(xO6AZ_x6q-Ii6h;B~Qc-4Jci4sty8PB$kzIUu_Fi8Ne7%6Xbdoh{Gf zQ|cvaVt^P8eSQPXIDwqxh7=W&YFz|A#c#0#b35|W$tSD>bCQ8x)IYD%+au*{*KfxzP;DH6($>uSTjEp@M ziQ%Eb4Xg~3eQ;G4A*H|KM}(9p=Zht!G5-Q7%{$L-WPO)>4%j)L1Gf5nV0X+jYMXgP zR9dgOKXl9*xHxnyNpxVq)_hslg&mfpE-_o6(3bN-ZrVxxBV98n5~BufbmUV$AcO2K z?#IdPahJitdxD;|-Dj|9ULlvOB!ZaXjJ2YE$q&NoYrcY(TNw`gG58eh1 zp(adO`OjKlN}<&gTJ@=AO+Q=*u1^|yB-C0)&mCPtrz7CS4It=~Kr`kJln8U}Sen=# zd4%Q~>|FrYv(SEB6>wH=-v=OEJ++B?>zP&t25sLRo8EY2df>wCtw=H;x3|Uo;PQ@3 zLAUY?e6qpZ%E3sC6T3|NdnAU4@=yGe0^#seOgxhiH^@&fBaWciiQFkTo48botQ6{3 z%2mPx#+08M7-dZNR~Wa%#^4|o)&Pz6M)il|^b~g+V^XfvDgYC?UZ}UBN1P<)*Z*)OL+|bGF z4p$cG_f4U+6Bt+#X+!9@u#tEp?9T@I<`KTefWP+x+yaI7mdGo1qPP%7=3-JJNM6(D zGa=^?%L}o_>b+!`)_Zwz*oGX5wj4#2Kq&Zizk!0mMd~!S_D>vYi-I*-9 zn;n#_WaE>CNEX^Vei19c=XeprhqyAvZ=+-9BK}363L8SLNq=tmGfO6eP5+js!m+2P zd=h{5W_AW_h^vk`U&f?kV1^`J1bGG=i#fR$X0t0~^K=|T-9YnFNDOWPlbV!lVme2L=i zL5D+nVK%!$#zkO1KwrJ9u{?@d)iL+w3K>^?Y>fv;Ed6N|^S5=(m-Q+$_mJ_eVRnVg zSoU=d9|+cn3W)HG{w=SN#kMoYYdmJN>tXqX#Q&RBS4@mzZr3r(>tV5&uj+-_?CKX+ zJ8b8UulD;=6!RN8W?ub@*B$ZVNqm{*)vwsmeT{&53!mgWoj>`kHH!H?q%d653-h%| zjmLaVFTQb|fFXTa@W12}_6=hUXXF>=sGeo^;YmE^>w00nUckJIPtxjE9vRXa1e98Ps%)qx`e(n6K z*-MvZ=uc+PTQaAb2_v$UD&cq++8ZoPRZaD5ap5j5kwr7$=GQK)?g2HQ`XoKlgi=X7 zGVx|$*=!&{rDX=7BC#t^UiHU9>R(@ij$ufsMWT17guthn7D*4dL|P=@#p{=lPsIeYQ_7zMu2Y94 z>O`lg#YjH@m@COg5C~_6Zzy0!$G|1R*Mj%Q0Or*gI5T{Q0dqVCj`+~FU*t`$+QohK zxuDxD`nex13H{gH^+(Yn&QK#hg<&kXN^pc$EB58rOXar_Q!7Hkd37`4H$W-lx(w(A>-cCOcmm8(~2E`r}WHHytl+@=KP!l8w%u4Ar|O^Ko5 zJQqiDFwJv`xXmW=OBQ;}*xtjk;KY3Hvlr*p=ayE4?@0+ygGTZPaBnfyrcJR!-F_cc z?n}hwFJ^Ku)=;>-VfJd(blp7#H(9d8BxDA-P#2q2Ze+jcJ&Dn4zL{ki(b<9x!qAsJ z3E2QzUisbLey>F_bG^XOmpuvFk(j&hyuTxgc{tG`a8D9H!;xm6n?c|Dq1gSCqdok30v1BQ6@pqKW;8I~>?Huo@8OxW=6~AsAHRndgSImXM@C61y)iE`>An<)w{F zFcW!?(z514Q)J|p>y%KAkfaeG2s>5%7yu#oq#K8=*ydZoj-lc~$e~a>Z|ApV5IfsDQinD;r<5m;0+e0gAE#bjg%X61uaQJD&u zL1cXhgfqkE0ZeKPT%z*L0fLc$*+iy_Kn`Pu?po z;VT1JQ8WBY-ZecpZR|K2LA?-i~ zXN9sP)C9_&t)aPCp*0#z_!{kCx?#Fr8(c%F)&h%gZ0CSM%>FdXklFnbyG5Aar=`?w zS;Lw>sv8(~-?H{&b{MWLTd~q3N74prgT>3XrjG*dso}=FR8U;Gp#$Kse#W!XGp_n= z9gTTD661zOAHQ*U>(1=X{HU?jx${_{DlAhUaPCxc_Xe+ySf6z6+?aK}0DsO)cYZJ` z@k-#mU$A)EE3dzu`*B^OvV<6bijlwWV-eP!Mrkkc1ukAeFmwwZcYg$$Z<# z4-wD`2t+~cgmP`MLpucJ>9hEB(0*w+a_Ewd9A1%*9Ne&S?4UCTd+3b4ZVe4a42pHx za9JoB9vh(Key#4Yp&T9?qw2K|Iw|i%M)y$Et_+m|u;-6FlOZTGPxT~aK1nw8M zv;B|ZpK1)ynMcdf)-9YdIM{CN1wzaAkG3E=HEtK-pUO<2Ft^lYc2zicWv4+;M(ez% zA1u}X&60Tprb(`+adJ96_+%iQ9_U^;n6q$z5b?rM{J7%W*_cKuHJli*O#MMMs7rg( zk$|&8Ymb&T@Za0nl`tTSfg2e%8vPl%ox4&dHywd>=uXS={{m2`+gYDxSlst&54NHT z&Yf#%{@Jj(io61wLVt4sbj_PhN1%L?vbz7tBd{uxVma`MU<-kvu(-b$zfhMm1ELNb zjJiZkt;3v2+h1(fGpLZ06@n+rm^wKdQ!(B!PEw|5d!rR{HV$U8U_(&OzL~wox;Zxv zMLLWlT!pH6QEY+nf;fb~gGFaF6#Bls0`-->_O(cCHDX@;CkuUN`7{maWsG(TWNbQO z60R($#euENxC8^Xd1?GCq=xM1ZuTQ z)gf9TJS*6=LDD%y>;M38MRefgfm0_7Z!I?1MS|tz``$%f^_Pbyx;jNEd%23B$ARhX zl_a7n@yTHz>x+oObs>Y{3F3OhdAq_VEQaL25}D_X(n1A55--X=Pt~#FTt_ z{lf75Hq;02XN&2m3|=miw2kZeQg~sbR~zGjPlr7Cd&F%4Iy=pq0uK@Xml4O=x9X@_3DL#g{NZ7iS$u+k5c^zcwYBBZH)8b2;W z1qvKU@zFRu+ySUl>2EfjHnCAv7{Ai3*3%3)s^>)YX!Hj5{Of%x;sw5LNQJ>rSVP1{ zwu)Fa3dOc|E4%SYijsVW>uSyk&|wq&>ITF`e^9ucPD@Jc0d&p|UbTRSA2g9eo5Y@g z6>s*08{LFN&=`9nMXO*>cy%fb2T)Jef>oH|%ZPSDAUShiW-FX7aEd2))2Db;Jq7jl zfJbU@W&mYCb)<~A)MYj_g-?Z*3ifj$E&imag>1i6STRs5@WU&vjriKX3XD;zW1U$` zi;&{LE*;`9z=dj^!pmS_N*em$o}`n9GCu+j9Tpbn#F$qFC;e=oaPt6Nc+A9t{X}?A z$o6wf=0`7)HNuG59qe~tbKDLiNd547S9Rz!C#*_+lPoY?@Il)#8#+rnb@ESSSSPKo zsp3h~K3M5LeBiX0_~2dwZfj1{ZH;s5^KUw*8B!);tPzf=I=ytCEFhL7r;jYlm7YPIPH}-kpE1@+Y zv<#X}7lZ%G@FcfvAjtwqesDr69@f3D38OD+p)XYE>!xNs%LQM{E&BL!mv-58&8!E| zS{@j>X_N+iVDR3L%T*80(DK(8gJ?kh_q*wv*Q+^xsN3bn8>yP@M;KR#rC@CNY+U%k zz;*G%?p%>q-4Ah00ulQl_Zz%z(%E%8*|~fnUUnFJi(MG2ts;ei2`DqpuiW z$50He3}3LIaJ0VmA`FgWMb4sr_+$0QoPLnJQ`!Hm+{}FsXl@P0wd}cXtg&hT(Auo8 ztUWCn_%EUT-Mb`=mZf2l?8rU2#-96fz@~ks9f*Lv({#|eu@R^>$2TpGkY!<`C-h>Y zuZJO5lGQ8U^fU_`Zf2G&I`yorG^f zbQ`$B^7qPT(_TsYXYlcc7e!Bl_hJp2_S=RR-4T2u)(xiR0`d5OBityGKv9IzHu+NV zg&9?+nTfUy8ztGmzD|Lod7=w9Lw<{qR@UeVCO78~8f<;Vy7y-873#aJzYTrtt$!Ps zNkvs1>x9BW>?)rm7qiO053k9!Jx`6JYkSH92I1eT+$cuEEr27>cTqMU^_E~WMm)%# z_UUwEYFy!!N^4bgk?gI|M>7Vb4|C=!cSBvCM}c#M@Qgf9@XMjPozs-yg%L5nn!j@z zIvIm|d$CrwbDH510Yd=Z5a3WDMG51BFFsup|Kig%@g!2Hi+@5M!yz z?c6w@{7`qLFbgHm$G=;-7oV)PTX{5+_FN{;$>Hd^Pk8oDUBZF zc)`dyQ`5gyimms|p|=CN>?A#bPse%|iw(^2Lg87Rwqz|9(K5&Zp6_eAr02q_GG z(XZvUgEX_G-v3$@^Y;W^@JLaM*aJGwQ}JbXqUYn?9SjyQyYa~~|KQ6$FbT#O$lMwF zqF?(C-e;LZKRSb1!@vwB2od_CUu!H)vtGW*9mV`R9dlpwYdO`E9yScx`(YIGdpc(7 z*T&O^2T$VL*~~@5+koU4es4lEBp*g=B|18#Z6y)US=A%XE)^+>-wiP56(O4~=4`A3_Fd+{U*L7n|{AmKwKH@P<^tOk~>s^V!}yFV70n zJHnF1)m3xgbKq`0^PXN1sPmb~qXG{Y;*E33lp3g%2B2LT!5ZT+LHa?^GfLnAA=cDa z9PC-WBFKE@K{n$N*9SO(9;NH)$aCd$>Gh1t%FK+OKo1fp&^%E}7hRcHlQW;=IW{CX zfu^p;@*Z&F1bP|ltIdwS+=^&F$$KM-e#P&PozVE;6X4nlxK_CW0EvOHT_v-=+yfs8 zUQj*1_272_UjjJ005+f$oM;0sX0qiIvQQV`ygDo>HsQ&)6{Grw9{9{o&Thn9ax>=> z1T%c}Y!8#D%8UAmBAe2zzOU&p0wF%k>Tw8g$8=b;eA#dR08ArjfPu|zR*zP|^gN;b z7ft}D2q6<3hWA;|3hEt;?&_lt0>!^~+7qQ?Cn)~gMt<+wrv~qxcFnz?E}v7gciOJ; z12gJ9Pn3STe9WS6J7&y{7hO7b!kqud-n+oXSzLeP&t?fhLxdmxQ^Yx~Rlt5w_DYSq^2&r8)rV(`*h6Wgj) ztF_u{Q>(RFqegkZ-~6Bw`o90q=l>4uv$OM@b7tnunKNhZ%N8tIceby3a>;{v zLpa#giC;PW(eiuBCYMxBzx1RT$GkS-mgC14l%4uu-Yv(^IOfsAuR7$miR-ctKWZrJ zwu!GzxayEs**L(xSNd*K=%?Xn|0;c|tM=+U|MEfUk0*A#yX4vTOO5v>kN$9bd+yt% z4|#^aaq-+gmR@js&mR`vw!4(4KJ#4ffp5>-67Q`t4_!tR(Kd=9H5ai@Rp_n zK4a6@K@%tCW^7uAsCd+{M?V4td|A^;U=;4#(+S;wuSe@U7L!D;ynwzHs{!XZpEY7Y z59?l!9=X>uxH$a*5Wz5D%GA&Go)2E~eX#jom!!Tda`5sYFFg73nSA}?+52Bg8K)PG zv%h?K0xP5mlKqlzzuvRo3BmepLY$rQ(inZZ6M${I1(5cVFGcUcbZWdLq`%}#(|gkF zFJGRJ=fKZ=3FiU#q&q+%Gc5R zd;3L%g0Z+4^jJ(EgRz)ER*cnwE~_@sedDUhhXcZ^Q(0t}p%_~)?WiyNMCM1A8cFJLr>UEC9a zc{o0)Vxy(>ea8&jZu*{skK@{@Vi++)_}(|e#)4%sYyx}|?nu+euCRQ2x*0aZ^l^>4 zd>b~ySp6iG73SMMGi-|)w$%)~(e&MJzP-l`d&u-XW4?XW413e`y<_^0MmbAvs6R$*piM>w<3gWelp`SHr@cp$4`z8GgvIC;9)9*3vNimT!&{c%&$xg66a2R7QQU5 zw3sOXa`Qz9ZXV$&V3`~?8^i?0BTO6S5UTcN+?Rj!#&0f zXqtW~zG4|=rVvRJG`?JlOmcB)jb@Zc50dqtWt4*lLKF@XVow&7Z3@)az~5aNn{S4O zfjs8T8-aXspcgZ2h41Kfm;t*ZPv5=!6I>p0OyTx6+_R(C?FUl+7ee|Rt2NL>>nW*U1Z|vN#~VmIUl6Tg%)sL~7$9w6 zSLVQH-i#|JVH9{^C=JUCGQo-HeldNIi;`LQhfvWp8ofb$kJIE~By1~3U*)ZoLk{Xb zm4%@k7HsiAeX#Ox-Y%9{!M9MqLxiB_XJ=eC85S_~2NedFUQrD!1~w;8!H?TB?#n80 z@7nm+4TzIUgY#+IT`zH{RQT|G@%-G}jQc|SRkeiLP!M>5$`amhVG|Fb`2hdS0#~60 zJeMv8wg|8zF|ac;?#qk;os)5&*LA8$DdN!sx2L#wjZUf88MT$t0Al|vhGYofpU1>r z1K5!m*l@;uX%?tOc|lBCCDYD!z$+%457L+~xIN7x@7|?o;YHwn-L<+LsL zR!M1eQEkh;Ee20z^$v+KT28m+-Yqdki|V%ApG%C<(z-48e(@rfo19%&*~_xnDJv4P zv^^f0%&=tiPKj@;$nvdK6i)~UJ6BZhekoC7bN8&oh|S$^Bt~rRUJx&0bN8}DU=7Q* z=MHI936!ZtPG1wC_GBs`yn92E8Lip2<-R46Mk}{%xqp)wHnyltzb7$9tGI2sABYz= z5mN~JB!UokX$V2%s(1TkEX-ccL9)j#i&G<5<%Aq^K?KAgRyNaO@KoIC5+k2c-@am1D$TfSJWvQ4yXluavZFivyBNI({noC_?P4@Ms>1(&2_3i!p82VSW8MK1JW z=8I4VFYI6$iM23or)u7|Xv)Prq-Vt2zh@)pY{0u$UKrTL<``GgZ2owk(Ht|iL&u=C z^Z+DPn+@M&__FX}*t1@Kb36&NHE5n^XY%*gg`cNH;+!U|Yr}~+1vuLWx4pa<{hzZz zaaatr>6f!Qiknxa4n=0NZ+{9ON9soz-TQI4sf8EWr|dmxIG94(!@(SW?LBHZm?k{q zlt;a9j5ef48$8j5%xFVyv>_|nkQZ&pjyB}uj31^e9iLQf9-jP_Do!{$S@@RVnJ0WJ z@H|QQdhpB^K0L%8F@C$$gbw?JU**)`HH^&R>?4in^I+h6yLx}&o)Jtw8BVYYKLm^j zoQmfLGsHduN?5mxeK8MwZyYsgK65A?*HY4@;2kF3Y~!39BXPS#5y1D*)}>h5#r_f< z`A0_>4A$GQSnd|q^wzWgWMK^u1&%P1l34O3!UP@L=qUsabSP{_N>gGcpO`kci)JL< zhVB=^0t5Q{G7$Y$5A$WC%-*zLfjhAyeZ8$Mm~m0N_X7R}jvs*N zYQly-MY*5_6f7#F5b5fe-q_pAo2JF4KZBCo2Z-&wjZ9u+dv8bAYBfhA1KMz#tvx`- zgxQsuUub_{(e&bCYj)*uF}pGu!ZA~oT)h2#Zx{lnVB(#VaW&o@LB(NnVs^!L{Sja7 z#^=^iaEV6q`%nuvtC~nbinkx?aJ=}Yf+2mnMD%zA^-rl@;1bdMA>KWtU<4o@iRdjs zHR)khflEY><8S>6MnWd0w-dVIH&jw^iRhh=cYjbY0uYZx>6;C;QKeKzB6=Huzrav0 zieMsozX9AE2cgG!{+=YgcL6tY5PBRRJOt{sm`VDeE#OZUrdv&ZBK#!b?7jNnbg$>;jrVdQM_GR?#33G9n0+=HDbSpQY{5_d;& zgpxxKm|V#jS-(MhK-<6u6+AZ9Rbt;s4ve=PzKGsN!v-Ol8}T`Pg$P0O$h|2D$=VHr zEt(eHs==^}-mPJ@C3-&^buD@$DFPesH|{tcCeg;n^csxxZ%^5{D|iEbzFRmI&%M7| zfak}%ul~BW?s9Hp;*dDXMkoR56qhzhn0}N2F3QV-C7I`fC7P{oWIpvuoJXA&P0!8P z@(w^a#0nm`_s~QvaPI+NzCKOwO4IXC!OCR}#pL67k(@)Z&p}T=6#IMfm^WOVy7?V2 z#glOvmV1y$-qaVT?#3#1vMPsQa*1iieT&9q+}DW#$Fne9#h2Oobz7NL_jR{1-vhhc z?yUPUB)Q|0%q?AU*LHBj{6A&rS z0lLWOmIWCjeNpBGlspKU>B@+5*NWs-mf#f?9QDyy%`JGvMp`Uj1bhycOQ!2v1h2w5 zi}Z^)TAh-yWj%lvl1sVn5%&nUSaDARmv@6nT$bG; zp;4o=%|^;e1o*;7A*zaJYA zzy%`V+Gap!+&4YrzKbCQ=Z?8zp8EkV*`4~#BjW2Larwv8PeDCrOV(5!B`SpDZZZae z9(UFjtcuJ}A!`<5Zb6i|`?|X+8d%=$zHW<<4oc5dh{yd>Jnoj_u|FtOD{?l3CVQ->WZUf8r)AI74L(MC4cSzwV>ew7CzJ(NZGw+$~G`6xUuR; z;K}fhy0Zct6YfOuN*-3NuJ}whulQuO8WwG>*qk#WZnA)`Eg4#U>`1Q25cck%|GD=_ ze7hsZ@0~EKAvbc&-c$zTM(RoEk+R*gF6-5U-oemF$R5_6u{v&2W;NtxY#R9Dct}XeP+T62jm$`phLT`jUz)yXPRXKN zq$L$Au0=Y{dyQB8rM?=<1dh3{116hhCH}S;tzi&~_m4V>s zXv!>kC*?#dk*VbA+-pDhyG5DnVd%chN@PQkU-P$R{T5}TM#z=O_O3g1lrznV)*WwP z(%>F@aP2!5Wg|WgB{+vs5)BI2WrK?u+%Clo&3R(*auFNMl^Duwp`2+>wCh888VHvbDkqa0NF#P6J{4aCRX7z{Gz#Lh7_~* zvKBMMP0EEc;6q|8m_kza*+Ys*XSO4RFw`HCj=cn_mz>;~2&vb!tMF;;S-PZgZF936 zF|mHCvxa2A(w?TZ#_2;^WAnv)?2uSB|~{X{EZRi#N6r0D~Ovi>w?SHMS81q0uWx6ZKWAq2tb@o`Zvg z#2wqX9%*X@%qJ`xI3_g_y~CiRj>U&A5xr0FB2U3c$i(!x`EEM36I>#Cha*AU7Fl8DLh>W`a8qy(nP5t>6;T<0AH30P}rntb@=S0?cy?&Y<^i zj2-;vR*v$3u`he(slJh|hB*CX*41x-1M5#(r2q6ac=YI7cuswPR(D!MZ-zcMz3@q# z92yO!M?;xI`rMHHCjiBo3Vs`olEF?~zU-mR(Jy-qA^M$+Prqs({FswLkE1{@&%~`F zCFNOMDZw4(nf*lrXI#$w$R0axMiHCx(2L8@xQZvTZ`{Rv;SS6KZo?}si$eY7 z`hthEcf2+(EDypc+>W7*S;3-=t7rfW);ydokIh){aF%{_n|?UDP;Jp8xVt)7)c-cR zin(vEBmF?GSKq?9El_8QvghNl*@t;9OA1e&U7)92imxyapItO>1Xo%V4eZP*dEt`4 z)FDJZm|mhU7|d2_KnhA4ija}KOQsB_lne$oXX~N;ZRqG{wncH?Pi`JYE-*w>Qdfkc z$m@R{K{=#|Xt6@l<=$6PHxqAiGOirQJ|{Y|?0X}Aujo!=Ma8a^l1nK@;8Z?&oN?uM z&=tl0<*US@0&`Oa%d^AcF3~ic3o?zTC7=XEsa+N(q+DY#TrMgago5&rab*sdiv9)5 zn)tr4AzGdpy&#>(mx#i@>NRre29_%%X;vr=KzHe(bPhXt zvC#BwtQgkkd6wf4iJHs33+M85Bh0j>L<2wf;^csVomnMdcbWS>Ri4#$YC5 zk|I)(UNXS?B3Lo-NB9c&V7vXbA`OtajH|wjFf$!Ew*tN6S$chuzJs!yIk0{v*HUAI z344pr(-&Nq56J+ryuqBGap1@8hQDyn<|o%32UO2s&38ZM?F&FyMDAKVTfQi*& zZ&Us_v5lK*DrSO0cK>7Gj28ls13}0|uCg#d;3~0_c4Zd@1&q?Kr2q_8KyrO4;;1PK zz&WbCZ5h1uIADM+!`w-LXca%M{177W07z)A`m|X(^R5rDG}fIQw~UdK%;@S&oFF03 zxeAg*Jc{pmA>8+P-f)?yFvDenIuf5g z@U|9NGVu18NXgWvu=;^#nlOL5d8SFj(7-ychU=kYU#Vpe$wFZGkDzia$0yfCQBCcgmH=i zOMPcH@0vo{SFr4}`|rD;q4B&SrX`f3&bY%8lEJMTkkaVYvj%?DvAKcHU4fp5#TU zxTWa?__DMM@svJzG-Ds;7{A;5g9_9%N!_g&Yo?eks7Lgx+kK+o2 zaE`J0rmHW~-G>zqWC$69A1#v4uGkgLPR8BN#9B)MhRe5=m^ezD0%7f6W0KL_KdBg^nD1A==<^>yEy!0IddancK zGaFnYdgD-DN8v-4D8C%+n+%vUY;cL_c>xo)!7+XR#wfvm?1b6ANP9=`ms?<9u!j1L zqI3v8lsakyj@NMXkRsv1=V*L5c1S~q+$Se!maxs|DFBo4$-}1rpOf)99v>DLHMn67 zjDw%Lf^273`viPW!H46QGx6c5CFeAz;**OH+s8@xaNL)(Biy+^1s_`8h4^sHvjm?a zd``vZM0}3J=Olcn%{fCe2cI+X;b=K$L^z&$7CzL;U-ko2j1!kBgMqXWY^@mrNx?^c z8?~4GGK@hSgg01IFrx4H_D7%VI~t}wCNRihI>SO@NeGNI(C55#rnsbL^Gk~ci#8&< zti^+Kwyry#$B5>^2+CL(o{O#=rp0MFihjz@^vy4=e}jhX5LrVOvKX-PP&{dLc4AIIc0*IN>vWh^1?xvpnf2A9Va}r4*Kyd6JO09g`v<<7I)<8BFoO|5chY zTN#PvQNn8C zY#L+Nol3*SpfPgxAFsD4QzV z2mLg6v*$=RIxZ>(XIzQaxKbn-*EeQ=?FB2Ya)i)vjjJ;ktR7Cvv1?PQX522y5Gk+r zd_+mFPOrJiZ5N!(_Z(@)uHF@+dl`CC5`{NCxa!C*{JJT>? z=NmyZ@snApNhSS#RFivDO((Y#wTlk}=2tejca9@94t z{5Voo*8`>RIKZ54gNsLx>6--@!}d84y?Vek9)uoieY=8zSGYv^?F8JqgV3W2-jXD} z{|4Nh2cbvyie)r1X$MRnSH3)b5PIa-ZxxI|GEshi2e?0vq6b0$q9^tL$7Wlg_&U3m zd`U|R&2pM?kbTM!6*^U>Z2Ty!bVmK8QkJcz#5hO5)5ekT6h=B#2ZY6BhacE^uoy_k zj&ZOUXxj<+^dUw}>7_FYlxCNBjeR*7X`6A`7Bf%%YKMsdk3t~nfMTCwv zVuA%(G~vEVtAN_i>FjMK6Y6%cu$a{JPiCX(H4<%bf&(0EWyEnviqz;9jj+yECefwS zENI5C^_k}{v*MCMAcs5=xFL$${j0WdkO*U0nnX|O{;Lb zYtxbr1E{OJwX<FP0F5SaU36fyq9^;Iiz``?T+zR>M|Ma46w3FAmu zNAjMkvmjRINLIwPj&>SVSivN+j*_{jiYja~g!3m#Kv@e#YiHZL#b_usZyQ3)061@E zLCoo2tPvl@gIj{}E}I*j1-{y#6>PVcI>SV*MWQA$VQ`e3cvcV7cMM=ow!tN8wF?2` zx534u$NE1+j~>%^31D;^Tq1hc1LpfSxOnuKzPkYPkPR*oy~hFb zTN_+FdaUuUDj0Z$OGNMQfcyL)^x8ln4c)pYE; zZR-~|d4IWa#P2cJm|6=jqenaz-9qnMe8@TEft^`HWYiJ(q>9l+7DK8S+hf6}ioq!P zmg9-!QI_VxlckiUP3f%)S4?R+TR83XzTTeGBP+X4$2)0L3Xgg~rli3-$|k3s8{a19 z;7hE<%(2AyHo0jMCmloX7mVR#1D?~8dRhKdOnwg`OfZb!tQB;p;UkisskYD8r!Uux zDNu1lP&%%|kb47IgKb+37N=ttHitus^A=-AnJBG+otY)W0Ouj(K7vouGHU4(sF?m!5%C?#N!GX1kBl z$B3KAGl$)HsSW#ufDHT7_)E_~)>hJUl*rm5m9=pqYvRO&EDjgD03z!k$NpsvWv!7l zl=VTrr8LVLdJ259hO#c!;FBsuq!PX?jV86^%X0WA7OC1rc(O23wKaHph3}hqO1RZi zm%xv~O7VmVt9B)X@Ozv#Y??{;dwm(&&=`cu6cL>1rDHDW=Hio}ugP)4|J!}dJfwm3 z<&PzY-D@RU6dOX>*L0(=xgyfKvKznYJP@hI-tM0E&WI9khSZaJzBmQb8CRllYubhs8)sj903md8-1@+M@#IIcY1c9?=NQ9v zj0jGSWZP|eRz7Dgv9IoFkF=^V4{L$V@;ovouB@22So7R2 zHX78;^ET~5)?M(?y)VB|J4IZ*k)BR-B8G7__H}l&cN$q0A#KeaT{uQUy3y(3M5#0H zlVZ|CbI0wXTu`>o+OxIDO3yfzuxzA<<4^3*14uX#m(4n7(_m=;*UXaZHBpuX_9!}p zadM32oil~mF)8Fck_F>=_93)0ilBC;^6=1jCuL45TUhvkDN5=syF7DJIngGf8bvwz zL*se>Ut@1;M=K8QXlw6iZR~_Kt(BHG`n`<>_1@a@vWlQD81|Ot`h&D!`K^rD(%iB# zuK_wMP#&nLDhrf(OQ*rMEu9AAwse{VY3yuWV^Hr~`Be?xu!fBuw-ItbI#3AT=s+<( z6lds1aiXxirn1aeS?~9*1_x@EsEi4$1B?sJoGHh7k3JW~t7ZD^?Jh}BQ`V%?XF0Ei@gCbOGT%^2&mRSssK2-d za9b2Cg)`nbgdZ=i0nBgJct8r^64Cn%FybI;z$BvgFy0-7CYWb_&=D>Xy*~iPIP)VB zz1xA$`_OM;a|}mqpNQW70A^Uh9f%&s1B^XI2cowXM$Jviut`L3InwiEz=-|Y@E<6@ z$D)}(4IjD#(VGdFn{9B3@_Pqheqn=)SH9OHqFsPFkIEX3BAbZbAYlHNf=iUXZv+2_ z3WoIP64CR*un5z*fIASqa}|t)Oib^efO9KjA`!hgcrgJmmCBxHo0%wmO98W5!6l+c zt-cX3zoJnBcOZIu0rRPXOGIxhUW`QxekjchxC6=Gv4A;E!6l-{>M66E?@c*1}_-3frSLO1$-5=pfmA9T%DW}t;)u2hgb%tj~RK5Fx2mK%s(Bi zax8gA&p&hHr|&)aof2+1>c@BkF7UmFI~N3Tjv-HV)O7P4LwyMM!mgU|APZsY zv+mzx%LKRN;I>8H^*#pI#c@1*nIAw#wKO?iwPRkge$)~@i zVcL#- zr}yTFNJWYU9 z{r7!`;$3z$a5Z-8Mawk|OPqXmTI1jXS7w9zX>9UJ(H}c+=)V9>KBS7#0k#sU+Cz9! zz_YY>O&>fO8$~*|x($wXI&L9!rJw-FLo++9e^z#60UYvxD1ay2FJibXd-HZMe;=98 zgC`a9alNp`gX&Dh1N}X6?q7X50#w9-$g-Jp99T3FI}_#W znA$TEjclINI2g>t0VhM9z{$o(R%^D>bVdeg_p1yR?zx|0_R&A(U9fs5&Vkvtd1Spj z2_pnR9OOMwY}OMebC>MvAA?(Tu?>fNBExeRMK6)VW4M-fXFBe;_vmk}s+4=y0=b^4 zyGr);5J99DQuchtUC+%^Lykb$Jfi=4mAYOQS1I7^B$s;#`}g|Z#})UUo?kRJ=#L{i zRY(U*B}=;mPbObx>~{F*QnYMx);JuL)dyRKzLLBJacF;njLEG>qjQ(B^#B>GMWSWK zE`={%#*PsgJ05RkiKP#G>f&if>5FlqQAA!5DWvMK=sC74BA2h3F9*|6RQaecd8`*T z*uE4_y8`E9$y$XCkz2x^UEbq0y*_}_h=y?OVt|8t1!lV7(P;J1rHXk?IN`2`W$DHbj1MGE-- z3`ZV8!~IeBg`oSU5b9_XYR8-73_yAn>`R;fm2uVAp)+(}O?dI5`EQXmVl2FW+{4s} zdk^EH-M2QsvwrNuLPJx%UKGHkw<`zE()yZs6jfb%;hw>Yk&pg?;oXwQ*N=^^%iMdc zz9=o@u3u%`_58d+++sc-SAr|r>AQl*yRd5s0CVTzz8MjW{h0x5Pz!|-H?GgD%i^Ws z!JI9@$@;2XsF7{)tG2=VslBaFEvQOuL|pp1E#yF%+S!-I8sbB&D2$QR)X_Oy9n zBXY=6E)pT9ZzycfBGCxFa`x-Nm?Jx+Ry#(WUEkSyP8gp15R;zC*9W zE%7<-Ur*g#@)%UsW4H^|@NV9|E|_uGX^}77QMcC#z zvU@M)LG<(o*$$yJ=7x0*TdUpcvXBf+P`O`$CcF|?&B}F6w3C_YG3qQSDsN|!AwZ5) zuiiU$>;FfREH6koQzRKo5NpWOM0_K7j=s} z+9f@h4OM>#gw*{+$=j>yH>^9JfJdOwt017fObLJ+)=kzT8HOC8#oHB}td*?GUWGc4 zy*FKdd}=UrEpDEGKrPn{8BEjH<&=EZdrk?G(|asRE?0x0LgFG7CUGYB3e*a0D|Saa zb2hB=Xb~@xhV$U2?wk4+NK8VhraU-bHd;KV8vEft>-noBnS!+NFtnVhKsgK|Jeaca zyrE6o`~ISj$E=8m>j-@ewk`w6BY==21Fi%4WWi@?SDU`S!si!Zcxddd(2dn3&wcRA z$uDu(S~?ZG;(5-vk_J1^kJQUy1<54f;`xaSg*D*d`iraP3a%fiFVqaS!#+w|C{DRH z_`Xo-l+k=2vh&>pBHuslZ5Dj@NG2)rf*BTh2j?3k=R@RtCprHD#2<8yk%j?FV4aA@9`h4IUv8yux1XKB})zJ2gnWnc{48D$W{Th)AUp9BouMS5?_VqU>a ztIchg%;R|lvn+g+`M_tcz6yOtW6ZORfgZ0pyyDE;?SUzd``rOSU zeXr~5LYqg1g8@XPIpFIH1}mWH1^jLcemKZfVPEi_b2e`u##12X>e#c6W_;#g$Dx@E z!?JFi+*u>-sNufXkbLZpzOzW+6bYP@i~|V{f-2NCjrw|gvb6W`tP?&wH1=ZY#%L31 zYG|}tFh43b=03uAqF5K1mOL(?S^E!kS(YzQ8?+azL)4V$;q(TvU4(S9#1yYa z?lgHwyxQMv9`erK7j|HaJPrp%V>BG3oEs;@4+lN+SFZfZlV1gF_0b}xN9*#V4Kt$+ z-YAaPXn=Jdh&F_VgEdV0GQvhz%OpdBN`@lya6wPjyuq5>%(>!ico$UH8j%mQ>1d{= zL6>FCSs6*0Q`^UV@9FK^-$Iu|J{zM!96W!{kQI&qm`mpjanPh0pDeNMMs|5l!Eedi z5PY;b<#uA)oT*}O1RLd4?E*a66sKw}c%CGDEAXV1m8$jN$>um!TZ<>vSE{xFPtr`) zF2|E)nktTnVy08I2k~4Ye2?MTh)`!=}C&H$5v`lH%s>0ZHti>*PkFIaY&mbnWv@)J1L=Il*!~{(^1avnU4@=KqC*+k5&QFLr0>L=i>lg}QJ_xFK; zsb+B?LRVKuBW{c6)*3NG+|$(9Z3W;Ag~qNnZiwvaS*tb53%u>C{cWrN8q@*tgWsWv;Q3}ocnKf%=*u$udlBOSCsj@%0`MiFMj&W zf-f`=URYdg+aGbXmFeW&ozb2A3#( za{+UK4K5MArGQy&gNsLx7Q;pb!+g*sqPG=rHywl?HQtW_lc|&&HBTaXxqvBBaEbUw zdS?OVRt0w;diMk72?dvk9`m~gFn_ecB}(63zn3_9-a3g z7GUBSNXL$m^sd^2t>CA%BnJ%t&#d5|g81YL{#@b1!(1a}tl+2h@fD>h0Maol_^mWe z#cNq)ZSc_ za~wu0!wa>Lei?yAFQ#vdH>lJg)}5CCTn=>2hA&l|Kr=&x(eNb$Q^ht3COcKEj4u#A zJg^2-JSmQ>T`RSb5fb*cwKhdg zD<~id8Dekv8R~YOj;GTpD}muidTAzfc)+cYaAWx}~sn?rbX@=X6Px>TEb*xAiVw6)rZ-MLh|Q^d_}Q69+r zftPBtT%2(w+H6f8vIK9K_$QxLmIEp-ZnkDz2U>=GcuZV!`?bC9$RQM}f>eAi?Ytmt z#dV{K>j=cfuIuP!;r3xn>ON~pvqWS$(fw3@3H=B%w)uvXCF0My?OH`oi(|&d;1aORjmAPh*X=u|wW?H?5%Hj5BasLlP!1Kb@+z|nI0eG+gqO+HToj+23>i&-gnl#9m~Xd`V!44gOSOo0;t z_mdd7*s}+iwC9q5ql)=!5^zO;`#cG_GXOW8b=T(N<(H<_vLxWhmz!hYV);UlH)7yo z`9hG-l7QoA=%laVVRP~FK^wm?2{_W5n*Gw(l60*;->-z5P@{U^>x<+pO)%vk-$uBng8$mZhl zkEZg5B;Z(&wk83`a=Rx9IGUitNx+fMFDC)V^tq`7Z7yDZ336f*a4e7VB;eS-btM7E zEPOvnxS=HAnBPAp0Y~{u@!(-|@%VBo-WPamK=8(cBVR5^0gB}ILg5r zNx)HGji*wzxp?`YJ}pcFj^);r1RV9t`Xu1UzaJ+7cRb*JlLQ>w)qf=cN4<6oiP~Hu zzRXAhj`h4X2{@M9+9cs_N&@aI&>Kzyj`I@;edlCno{N{?YU#;8+w*Ny1&4 z1RUl0mL%YqzNeFbW7qAIB;c5jOd4Z07mt6GgK0^?QQwy*0Y`a0HwicnsjN>D?wTav zn7;2P0mpbBOahMi_*D{c?7zLA1RUvQ^I>!G%7b!$W)g7JSLY-FNBe415^%ME`)&+e ztX)F=_qQ0h*nXJ@aFfU!n~RrU+LLD_0XGA1wMoKlN&=2m=%FOwSRQ{!0*>wFCrQAa z3Aj_JRBbLEUsx}fCILr%@Qozk$mgq*fTKxrTM}?yzzxU1#mWoy-#9*OE?$0VI-i~d z9P4>a5^&5%Qxb6OB5z0njw1h^B;Y)Ndo&3+_Rn8U0*>XIeKH<47mt7YT^NT0+$mHH zaO?2#YABCUYd&ZXO@go%QDEW5;FDVH!6Zx>Mq+(zuKK}rmivx0SiQ?rr$an=K0P#qak8;2*JP5rX0>2S3snaF31M%f+ zfH_6MB}(5!kSS6ylHvi<2e^d?p;yE70p@lEmx|ws^7|LSd^Cz4hLXSN$=(048&Fz% zdb)bP+zNxT?(UBE=B7w{SEmOH=sJ7bK(w{R6Y1*mtZeFB>*0z)9KX}rt5tTc!VZAjOnYbF$|WE?rR6kGZi$zGC5R~0*Vcwyd78UgTI0cV zkB*;dNA8xcMDF4tOzHE8g@>K3U46ZtC2J$Cc(#Hitd-?OZ#v!$ceGo?=p;^5-ZVGBEZTARC;c4Ac`BQs*I4D>Q~@t^O(jZ=Lq z!FSI&{w4k%O)wofZbe>@cv+mYJ@YDjp2#v3K_`wv_O!2TTH2cL>1gd-8d=8J6JT{W zb+kqzt^Wol#o|=saxA3&0CCsj^d>^!47skJrk=Gznmki_H9wD#iuc0fncsWnl$LzY z{8sT*woHC?;7jAok>BLil$P0^mS%)|n)uY_N1A#fp87V=eAJrRvJe$td(}$_btU-| zhtiamWoxFitnyssAQfayQ#EF`XLWl^1nKF^_bh8|U%D(Jyk_As-P-(>U0so7EVIt8 zh^M!&8ySxvr>omh8l8~B2*jePr^O>~?;uwm8%>tI>LDZ2TnWX)ZxTEV)eW}zn- zhdA&FM3HqNic$|;)Yk+paIsJ)+FbdA5k$Hyz}WCJ@$wY$uV@M0kkeC&`VRC#ooHRt zjgzO45Qk>bYTJ98TRS?MWW98}vkNBU5Nts<)-Z{q1Syf^M%H#4MPess>ZnmmqBBPKXJZBc)OBsSqWR_@k9W zn?fq3;F&6-JdTQRh6P&NpiDgTu<)0HUD*kZk4AuXTD?+*EE|voJO!O>gobNvmWmmv zRG^0Pl~A$?Fy58ne7R+4P}-Y4_SdtO+*`^o9L6>Gsyy?^OrZ`>wwHpbC@p4s1Sr*z z15&C|Fx{j%+hcJ(-_zF7w6s?wp=gcz%D3rUWX<1%TgbXl)$Nk+iI5Myo+h*cY)6~B zntFPrf?v{vmDFUZXeQ5Cg8Aqfr`9(0oH}jRteI$Fy4UuwR(taNCwmx_?^&>{Yh_cf zr{XkE4WwCH%!Bw?pQzv4plw@Qw0Uep+j_cI+5<&di|C;;WaLl^y-?2G9j$E6WF=jM zh3kDNQL!Q&Dea8(baix~C0&X3skOy}y8{r&*3~uxLZ)3N+CzK8 zsgqAV^;8cQ?X%f$Y42U(>FsW6ZY_nXX#C_J$zGfT8dp2M2+Rr3H#+lUE7RF>M&R zKfsgMj5>grPuA*?t|rUGn+?uG%k)Z(tV~3uCLC%;R4=6&JgZSTn86mIs#-L`YMN~* z#?~epMi6xvngEi9iDu}b1CsH{`x}rXGK&$Il>jm)HhrLWaDgGMRVJcqWjl-+SOO8j z0n|)Sq#Z{gGM8qh!~3?no&3~5okrA{`9oNlr~!rVe=s_5B8;q zM#LyP@q(7Er=?Gpb6-cK9kt!l2Zp0oIpUGIhYE|ax!XH&_oy_w%U5=zy|D$|gXmpxF3!ho9XG3e3QUC}FzEFpgRo@OKm36Ld8iPS1rLjQInjIUyognEV+k$TCj zob34;wGWkA2&`2`rZl!eK)ZUZhQ#dLt!lM*lR?2w(4=N4{{(2FE8-D75s&DIc*;aS z#9rE_%5$1s24$spxz!7r3F-lPoX?B<*sQ43ivkgQy+l70$7{FtbhI|DLg_Kp5d1Cx zJ4#WBmQ@U7J!EJ!>kXk+ri1JiDghP*Wedc{UWH116BBIc3aKH4zHg`T1+z&>u~`{r zn^M9&nnfl0IY{JerqlRp)+z)31++Y<_QdstQk15&I4i71Fngz587mkyfvz^V-3%#% zP7y7H6=h>#9BA?P?Z5z6bi8 z?Ppv28m+9RvZAhW!8zgb`0wXq6lN_9R#r)2jCQmxg&xJoL!_r&XjQaYop@u~-VhHk zOr?t!AUdk1%ow9>|L^<%pBz|^A=y-M3PZo}rGX7=g^yc{RtX> zTPb{;^I0x@9{83DAE)?QgpY&vO~S{u84be6fo+~Johq(4K3n)^B5a}X&4F*8@Oj~@ z7rp>|+)th=c6(L|AIEsP=Q~vk!^g8EQpLF|Ug0|%VP^{8`S8saz6;@-A$%?H6$#%m z_@)V82YjaqUpIVHg)ahMp75=KZ;J5s!*{&!ZGi7M;oAgXj__@P?`Yw>623{ow-r9_ zu}{^mgD+F~ZiH`w@NI+dP~p1?KAux94}we)zS|Jy623d&`y8KC?QT3j6~3S2xlj1+ z$MZws`vsow3*UA;-xa={c>YcJp1|{M;rk_?e-^%H@%)qU{RYq1gzp7BUlG2S@%+8; zy@u!W!uJNAgiRH9;p`SZ(tk$y-ox{0;rjqj#+WKn`MB`y$MZ4a(~z%6g^zhL0@ z_#P0xbolNQK630H;md-Lxlh%y;rog3k?%hiJ`a4HnMf7qvD_+rEWPguUp{>QEqvTN z^k2e98DL4IYBS-xUijv~ca88-lD;W?0r;*Iz7Tv-;iEiWCVXM|283?`d>e$1QhkZ= zoe$r|!gnEjtA&qsBO-ju;JZlpI^gRRzHazd2ww!gWx}@xzEl-3nho_-=!*O!)4A z?=0cF8@>|Z`#F3wh3|g&iiPhN@NqgNRof09S8AkcJK@V0z9-=01YN53OZYeioT@zw zA7_|Twco(!5xy7T<1A;Y_A-2&cTCk@gO4+_soERxWeML~@NxDiRr?!!hY8<%@QoL~ z58z7^J|0(=#yfA)7LDvS?rut3?s^MvwT28l$hj zy7N5-6z+^}%B6(sn{ru=^t8dO+<9TWEPdozoRKw{o-2<_644B7_sWyR^eb~&dvN?y z;V;FTjXOzkXdE8bB8pVOwrhm12w~rZFH4*ic9rneA&f=I`=btpUlw^GzFmSXnl^~H za#JDp2jUX+Mf$W$ju}|jp+!;$)-7}QAA%DS=Q4>Y1Hleg!_chYvi?JGqF|ahf30DN zG&yNVH%2fM3x*AvDLPKF&D#9rqIDBWLXq`pdbnFJx?=BfdiNR};FzO_`%9kcKeA-Y z1|YAWuvq_i>L+^9BaJxcF)bR()M1W!{6pBxq; z>ZspgZyJ9Nd(-7tCcmPgWzkRvXbpS2WpIT0AR1Z|4fRI_Z-$6Qk&^d?k-w?pIvbW= zst|uB59$nXj9oUEJXnMinrITm(@Now@aC&Lc517N&-$|O*K#A+?NT%9T1mrEZ^{XC zLZ>Jc!iwJYp7$+8WfZJtotL^;p05MW{gTf+=6N@U+?egJC z_ss6w9<#8XQ&@y?Vo}E3E-G%in<|=6SB$t0RUX1Pu_hqI?V|Fg`}^r{L#-KDe&r#I z6N~EH?V_Tm>wl)^P77;|!Xk_li^|;XqTZzY-qS&}xkg++RvyAQu~=!{t}}=Nw`wE< zc7cKQw(=0hiA5dZb{U#-&0VM6WnrB_VTU7(6YFqI#OV<0jAsgz2@sItQ1w53FE}# z@*B6yXf*eI>!&YUSm!7#!Z@)g6>gUi*Z5bC{LsSsfx;q;6DwO_u^j1cTQ>e43+r`- zMHnX*x#xCqxf5N@*E3LIgaSTsMZQogG24nP{5KU-lD#)(Be<95x$lP>SN zInP>H+Y}aIoLD&su?}o{@Xo<<3+uNEi!e?sa?kCWf+yY2r@aPwFjDwWg+&-A7E8*~ zQ9CExzstfZkWGv*ft*<6p4&y<(tY~oqgyPj4uwS+Czb~xZr2HT(%l$*{v`|RW`*U! z8zc*#dW{JB8(G@C1tfKDO*>=Qa8$LzrrGn6YE5QW$5`o zUA6T>3u_h|6F9;+v6v&btC%n0R!2WO+rly~y(Nqji#)eD|MK*Ep<0X-{#?aH7$+7@ zd$)_4obKtbe;&24(%5jp5ypvi3PP;b;l<|fy=h^crmzU(#G=h$wGP#nrmVNHniUpd zoLKn+i}j8!HT{(zSy)UOUgBjN@u&_Q-ScGw6Q9D_7)U~I)yWGMmP>O*tPOLKp zmSH*gCcl2Qg|$Lq5ypvimIG`055_!XVSQg=5ypvCDzJ=}=+ufILz@|z?NxlHD6&7#);)ah*c~9`}%WpEUZC= zMHnZRUtqD0)7_o>d5eX$OJNbli4{PImBKOm{``oAW!%b47$;V_z%rz_p?~{r7S?QK zlo7^>6%<%(HR!f>zxsHd;cZ1wAX zg+&-AR;9q2iYMKhO+z;6Ey|RkgmGe3A;c=L-_HLls-Phoy$XvkPONHybv&MQ9UJ;= z`tUA=MHnYm4MHqS@9sS(?6Bf`OJNbliB&7GAV$I+al$957S@!BGL$e*tU82PoZo-S zzPBu_^A#3hoLKb&D+^D$@y$=!^x^dii!e^CFhVSS_~8dRP)G(3A5&O_abnGNU|sm! zu|Kr1j0?{Q>vabnF!h}D{}DnH>R3u~pqB8(FYN)uQr z1KRxCv+uI7zOS$dK zO>dm9f(hfqxK zf4;%O8dO+>abh(KEQ1>#Ua}SH*(l{l6c%BeSZL(HjT7;tTmImYy%yHL6c%BeSgi=L zwCJ|aR;;kFij|-d#);J?una9a`J&G@TUaX<7Ga!NO9j?cJn2^d!W9B*OO zDJ;S`vA{B5dGMrrD{mL7wNYMM6c%BeSRDwl`g-+KZv2OZ^@PGAj1z06z?y+4-Nbnp z-e6&Utgr~<#Og$d+ht%a{Kn1mEv#wTq$H=@oLF55wQTI4^=6e@SnUdnFixy)fn~@> z`5hJiWntZ{un6PCx=3I_O$+y(X|q;YSg$B7!Z@*d5aM>7DUq}#r+@1t3+t$(WiVl! zSg07lQVK%5F7G>#BBQ**3X3pKtcbu;0;jz)`w^StcksT}l~gC;uofYQ^;{g+&-A);9!} z!HrqnKS6*|Ui%dmVVqd~0!zKtR`la$Dif>Z7`%idj1%h;gjo9U)A1j^YhiUOEW$Xk z)(I>Ro^)3{KKot^>qiQUFix!X2(iXRzZLo1))M_$VG+iOwLxGRa+vn%uJ2lLc~rF{ zj1z04z}oMUTRic@<`yU{!T`&*_487M$Z>4)`;Ix|2CX@^4uy58=F!|*ZcSYwNgj(2 zu~K#QsA(nesP3 z_{WJB<^76sRC26$G{@|5T@e#kG$t-xz)ZxG?&7h$_{=4LXz5B-=rOr~(2wGe9zz*o z2bdZ>Q}Jo~(;uPy49Z_ulm|iC$@!~dC=UwCrvgJ=T<@>(*83}bW!2%J*S6K8wAi*= z6hFGUN{hK))N8{7lE0$9y2`88MwS+1(PL?`xuUnXv=}=jON+%8NE0zo>8%Ua`pN?J zA+Op;T3XD7qNT-L)?ZpkEbJv^eB4Z0T5O{FYP^APFdVF{sr8!6+DnVEm$bCFtIeRo z?WB%N2>kWl`heeG9;m7Fsx4fMMQt<%8uks978_elON%?r2>s>Wu&*XiAFlQ#N-MUV zmKLj}tEI)wCThUv4dYU%a7Cyt5vsWxRb;`!MCSbU75?g~gpu;1g+5^MP7JXH&O|Qv zd;LCtRefb$If?~qPSu`N6pOVfRTW96m0Ev=x4OI{de#1_(qgfF3VGsIR6`!H z7nLDqe7=ykrmChQTpkR1jg4oe#n`-5S}b>`mKMvzinBhI%=yZ_!TO4d>guw3uh_YI zP>evix4gW{AE>FXNBXRNtxStr99&wAovku9ln5hjF;f|+@CNbwcvgA9}Z%5 zULVRmROk23=LVwE;(F9|?wuhCnNmv(oJ;}hYy6?A@|rROmwH0%opUlT>@5%Y%W6Xq z5GIy?@e(XzTee1gttu_P$V$FF#er&XptiEEy1t^$h?YqfJAF%w3j{j$$20k2zpp{1 zue87vfiU?A)(FGDRfb_m-_0BWLFseE%Ql8Nhs z+Apv4)s=yW+Uvh4|tQPd|BlgzhC6cx{3AFdD71nQuhj19~2SnJ4H$Xgx?RrzZx%Dj%< z%<&LWCfHYD#_0EX(SG`B%gTIaHl!dZPOdR|YVK4nEfyPgsT)BIGMOkb2@i zMpI->3#zz7rz{ zMa)vcbTeucVX(R)Tvlai7PAZiS*Ub>GT$c6I&Y{d6s#_9WqnAUc0Gg1o~Wo$<4ul4%N%EO@`kS)7|8@5f6VAZY^YERlDx&A5(z1kb{ zhl9a77@>A_OQ0-l(e4A8t(r-IjdUmsJ0w)*RpyS^E^fviE0A{dK)tuTqNYAj>qDC> zw~AA#o7xY%m!RRqZgJ?+o>ntnRJxkVDqk3a>^)-%1$g?5(pj}lJ*Bg_E!u%n%w2+ zh|m}GmRHwQ1S{%lz1({aosP}t%0`O=?-w>;$nVFQ?y}m*{sK3qtM-6f)2V^v-gGlz z$WaBFxGG|*o$BNhE@Go$XY5r+VTjG@wsP}@y}odDy|2D9jDokdhemtm&|7F~9THpZ zEf1srf$qz}x;)q;ZHpCVWOZ3hfF)<}QL&>~6m*P{Hp|SZuO2p?ud2SRtP)LU>k9Bi z>|IC4g(5Nv)1F#jmY0XCDng-3qcoDl1b4&GwP>4y-k`!^b1V1C$Hr<^3slQceO-+& z5DrYrR?PRpsLDVk8rtAXDL5@m6}nHMQXye;w@PxY%NEz60GtuJ?w*0bf~pd08Cf zIMJg2W+FqF0#)If@*1SuzImTj45+Af)VAEgZ={+E#x9O%Wh&}wf`K4Bb4OH1;?7F9EYvKC6zUnZfvZl%_OUXJ1 zK+0%RZPkGSsP*zh0hKv*rT~~|^&4SQl|xOyHkAA|lqSv|C@sd}0?yKa6&dvT z!eQ{$9EDLGc4sTZZKpO>2Ay43=?m0V)`Y#HD^)DdA)v9=DtHJs7)KExeU=EJ&8rXB zg{vzp*)>ll0Ct}t|LSl8J0Gjdt7~iPVDQEpyb-&C!JyHjH)vW>Lo2J1O|RH?kHY2d z{y3oM)1cFdMzt>NRVNuZI!nR=MjF*&24>P=PuB!}wZSk{tUA)bKBgl$r^H3<>vkZ* z^o+8%@WS58K)tV~q9Wjx zMhYLW~0yRWMu1&9;(lk1&4Y*buNe{D`G449m!F zb0mUCKQ>TSQBhtNt~I1WssvTWRAb1d;-fSWth5EZfy&x)e_1`u2p-ZU0V8q_CIW zso^m0RvoGgS3&8^V<$Mm%yTE8pOAQ2>guQn6rt6+W3<@stB37WQ*AI*9YbN-nDQVB zM||bzJXM#KS5#tTQ_?oavyn}4KQ6eT&ZwX{VrCF3*jI+0o3FMOW-tsEoJN6W30aGu zQmd}`F$7Q*2vqu!Qd5hwHnC3ebQm@esCYb5C9ZgeU^>-eU?W^^I4W!CQ$^T zN(}ghtD#Tiv5&R^;#H7PGt;OWR!0JOHFcf{w$fi7L?_6I&@fea;sx7%s#__jcHITDFjP~HVMBDWjN>q%Eahn) zED;EgI1vMZRGIB&L1G-Iye3#3tgeBTk3$(^gv=PCK5YQaf2dikU83?1T z9~e5kb&LH}dsHwjD`6Uh{FNBnvIf{4stB1ks(~2DGr52fnp$5~SsjKU(OCJRCgs^1 zrN!d#4al?@6p|%o3}~9zzB+GxRe4o)bpVq+M7EvCAt=eI9&sp#Bh6?*0-?G zJXP1%l?8(s+ZIQLP@juKL#PK)cf_$F& zT5u)1I9Q}n7(bW=r%58`!X=EjXS@q{txLHu;I+m^+;zUBv8}JO*=TqRG4LBM_f^!2 z8^(J}&yf5CWN&M8ABHm4Ha2&4t!Qu6y!N1Ft<5Xc3vUrpfaA2RSWw$>z>xJD`EHG< zRPu6jD9a2nAo@@7*$KElHG7Y!6P|c{Ensd@a3me?w&`CW{3n2ECm}e(B|1U5 z7cc`hIMM?zzUT?cbHy#iIE|%$gjS$5#Q$Rku+UH z9*{@yw1r2p-cCU8m=`+vxLb`eSj2ZHBP!DzUVL~^5Zye6^ zVV>dQ>E?jaj}ijUIJ)^71ow`Di>I5P0Nhxm9}RkmbSbxFzoKASJn?k%jR^lslJwR? zHomFkEfGDey3)R_U=EhP8pzT4lqI-C^e)7^Ho)w%!6nM?vw(Tc1{W{CN3mnePD;oS{@X@?BZk(G()T@ILUDL8}PztOhMQ*B%Imu}mdx^doo%a?21 z<}ZHqm&o(1by<;Y{jv?nm(F8xpv{MaT=S|$*JbH9Fnq(sXIH3r5Qn;q;shYtpp7%L<>ISy$GWas7_FUFU7w@hhgTE^DZ9`u6jN zm=;zp>10i0dtkL{1dkjens3pJ9HuYIiq6f(K|m_QdfghP=xh3z2p`=T#Za_t_B03?7Q9g+mEI9ZI}hLMs3zg76c2%BsiPn9C=AsZEV zp9TUs%kRF6j6}d}TxghShGa|2Q&mc&tbk_P>0iK1W15j02j`8VOl+8`BBJ$mJU&_4 zt$519Vo6xVMm0=luwpX&U!}dqX2j|2_7NKax9bT7aPPYhoG2R*1{iIlwAbwGgZaj3 zA0@K9j9Nc-&)`;zGDVdxdCSY5W~xiKi_JIP^B?Yb!=juo1HsYJ)*?&5ndWiArn6H% zM8I5#CuCfEVgK~2EXrPl&>a#(nY|7t8x z|6SbIz(-YG`<}^6CL@k!fPqFDHR@2Ka3K)Hq=`B}2mt{De$;K&==EWWZ~EN_%asZ7=rqws2|t(0UcQt-1gI-sjAm$;=_C zaIbrQXU{(Cth4so-)pbE_C88;AjMQ_Z`EgYEWlL@?+#PfX&}mlQiF^EqBd@ILo!UE zQ9g!J8LAaiL^kAX%Y)HHMa8C;g8zMKD#jHSS)}11QX2N4RLYF(NGA=?V~$##jWn$H z!b>L&e*ij{qupd15*?e6o%D4haHbe|tcdBPLq47buf~FBM{fae8ZCHs^wt7ry#>#X zo&e4_EqLkZb%F6G3>>g3oup^khCv{ki2YtfB`KRSR!$f)6{}8Y{@kuc{Bxx7Yutavk;<>V1D_@9*Zvhg>!1=k z*^SXTH7{GFY+hONXkA(J1_7iH&8Cl-r5gy}f|!Hb^oYzjoHtn>m{a`0sOBp}H_xEh! z1AVBN#)(j3wi7GQC$pk?dU$tM}!KGsC0=n9$AU+ zWDJrS2d1H*){Bu-ZpN^3G)R3DISlOyL~=`J-E;)E>$0Q@x%o?WDNq@+Y2rX+3eqVj zZJUAv)ohGo8l5=>8H;eDG;U(1^*aJzQUu0azjp*TCP!eMnvUmeuc<&UUqemHU|B^c z1KrZIDou&30w~gBcz9~GQk`F9-e0XW>gQB>$g0w^78BQiq0f=IVyZ+iRlM3V1^=zi z+QzjEv(NOH6WSNSL8AX+anPBWS&FbFGx->*09Mv>ssdCj`Vm&*la9z}cuk{Q)&;y; zWU%Z|ZUBXZ0>@;^wU6yC)MeE0Lfo*r_~lvI2_`wJ)0w)02?&4QlgSI z$t}1^nshR0_@ce^>2byQ z^2*R^deZftR6*U^Yf_~a60DQXEQymot__MT%F0aXqXtCfhBaNDl(_6BxMpvB@!o=e zPo#^I1RW>1&ZNVN2LS4HkUm|@>%aV-W|V}c?N>l4EU40X+ko&ddBH|af;j*%SLsqG z$`nML4t9Zz@1yr74sduhU^teljIZl}@$qBnj34U%C)> z!j|V@7@nHrPHg70!|e~6vUKy`a=>3Q za1fNvZvKldNAt0ZhqI&iH9Q+;;7CMxcJu`BzS#%8RY>m>{iHYKBCPh}qO;@g2|ODO zoMQ&wx$^HcaX1*j+0nZb&jtYJ>joaP(k{I}1kNjc&W5!r5*D>{V zfgHUyS5)WfQ}V>*JpH!795ExH*XGw$i|YIn%s_oger2@^JJaI9Y}2I!MKT%WwvE2eq%)xPMbPO-{&_kie+ zWsw~=NLdxY{MV)5I=%I%zENUFDn=a9&xq-P940-;S6sy< zS&?fLzoQ7K*2JnDP?GtMCBs~UPBf+x-1Is#0-7X$w9^qiSQYK6DnSBqFZteFf$46` zt1_EHb0cLfuR4(bj;6ugt%pJ0v1xk-?%TI^<7U(SPKH}!2rtziaN%aD=-`;VRNwBF zcUxb>U3fl9u4@KDYyf_(7Ctl5FTcLThRZP*{V^I4+jxeiX5t=%p>Ekw0a7pF(uyDY z9sKpz*67b1M?e>>DC7GFW@HjmzxU}c+RWw^foIPgZCErtqX8`%LPv%TRsADH0I zuCU$$MPtWHXMV?p!UGuj^7-!OZ6|} zBR5OMWo!c7E?}+uE%Sx3MGrWlhg~JN6|tFRZ(fGx0RAFiBA+ow%K~{W;FNU8d;lbS zvy(U|4Sg#=2%=AOb(94vnAcEWZS0JULRMQc^1i*F0v*|0cofl#TfJtkZ`SeP)KKJs zKP*;zL-WNPA8ab3hZb}d9+maqF~?K9mGSDWtQ+e`>MtC}oooTREQr-ZS^My+*$!Z$ zK?1CVsZhMDanNR2WN4$=9^{9epd+Z&&*)QJx@TG0GDj_HO%=-FwAjmNV{(X(mAi;8 zYI2BI;cB3`t8mZAa4jo_*0H^X{{8GwL`|N6b>#ys2zPAfaM^Kx3w+U>D`rx2D9Q^u z9$*)Mx9H!`Dffn03;gJzJkcBsi<#p@O_3-s4R!H=FE$*vv>M~_YHn>Z{5)K$KY0Qn zI)^cHry48^Jl4d@17Ja^ol!Db?`knJe{fnM6Z9GSj8cf==d` z-bR@piqb<~G#ppYd+hYC!{yhgYs!})YU!_)A$E&o%r8F(_9YpDCqF^Pe=VRfz|1vAp9SqC4PSE2Z#DU2ZEs4-)XVz6ieRYgdibMp`DIQr zN|lq8bm&YS4M&>)P8|&;>||%1uX2pQA;_pX4BdM7-n$anBr7GKqaFYO?i%USGa)4@ zkjf;8b(Twd$@4lpa{_a8sSJJN=Lvom8!PcOxaHVVh$I(o-9QTGAqPt zgEI9m$&@`QloS(a*8Y_L4M_uE?YC>nr1$d5NlkF zB{}D_Wttb@4K-6#-!@-Dts&4xR(YOG$q#XzEVBJ4JPE|VhPSYgB^0Jwei{|tG*Uq zx)4eYE1sRbvY`i&8*Afw5NVdIB8bD3t#U8mV$%-Vuy-~RD5*)-;zrCWo47@l)*UL3 zRzv4d_;=|XipLaT4OFF&I;oD}XW#FWE#T9*o2GDj=wrQ8w;FG7CgK3J_4Mb7QA%jTaEmC z8aPghm~iK+FC&0cV&K{F*9m%)fs-lcJ?FOlsRqsx1J8~g=U!g}&ezem&{3MOOYdIb z#0)%>-sh@&l7rLvnZj^9WRs^v!Z5RoqIDszn{cuH@M1F=jEnPwFXQ48D8+EX+0?A> z7UO<0t|DA~&gwZ77Z=P)w-#3=E(-6gK77V@LHsgYD{xVco`H+}T!V{o1#!*7)qv|x zT=Q^^!4>Ab{Ex z4E;jRWy6Ml>Dv73t{->9_#2Cgzl?)6%coRKoi?Ycx~8`7_OC34{Pfj^JC?1EG~IRg zntRqpH@3Fj-!3+NW*IOB1?XG!IjkILejzO}{k0=cd4LL2*^u618j8q%wfNNPyy;u_K@>=D*I zR-rXrlF<8>JywB9Zr+RRuSXnt^$b)qBhFCW z$llxO{8YHI^_hRY02H(LzNsT6qN>QHUwQ%P=~c)UDB!dA9ueLz=rf@pydbG|A~%up zXv`;EW1`)@4Lu&THsmifXWyop3-Lnl)P0{Ex98s86+(8gTT*HT3ZZPBnTEob&@62Z zbZH(cWc{_^*=)Vb?xQ#2fU^^@vG=~O(0~D` z>_qv`m*}p<1;zFB0QTR`si|E*Fo~#s`qW_3Es=EhOS} zG8ZiMuvbNHE%S;>@1~i)_6lENPe-{^Hn;3OjXl|WDnE6;jgW(Wf%D^Nrwisn9i>B? zj>7aPwx*Yt#mY;az$!dyyh2){&Lir)G07(uVDO!F?$jzT zi*{C-kEReU{^+i<4c)tBT#O;+X2lgVeb`GVW+umDWh@6PF(!$Zz`G_YVM6M)MkMNd zqRx+jLimsfYa}A%6Cu9{<;2|NKb{yDZqg=Z5+g99LmZ-Ro~T<83szCa6BYI9oAO8^ zo@L6!7`bqJ(u?HcuY}0VjJa=RI3=m%!kVG>NmXo!x_VL9AnKNj%BmC=;+YVW+Ao21z?5af)P z8)PM1lPenYxUAF}D0yw&d-EkJ%Kvm3noIUr)E=V`KI_7Gfsw$czrVhiM1`+;Xh)r^ zV`qTa;$qV2a)Hi=Voh!sghR0)WqB^W^AC~C?OLW)7QTBz-X8KW$5~q$gGABl_yo>j z7)-D>q9;)s3)q#^>dmF+TwsXyIGeo1&B3O@(nbQ~S&yqZt7GJPEaKts73OZ?yTv;e zAP*y+;-~BJfA7fX-v;Q1v7=P>`WQ~y2-XL5xH_HqRnCz+e7&NLZ|Ty1i8)<2C+hBsttMS-YuiAF!NBokm!m-{L?5o_{9V?eCQ7mY=t zE+`tyUb%(fhEma3AsVNP#(AP)0b5gJgJ@hX>KbD$EkIzM5xX|hf3%(czRmP^KPVxO z$nZ}3yU3W>Cz;&68{wMF=iwI~HMv?tu0%tQXv`ILl9@)y3^@pjx-u+6p)A46JkeMm z0yFbP-E_3=xm{-Z^q)&w7$ggimi%Y)HPQ|UH4RAy<;onSH5SZcYMpPeqW#}>za^qf zD6nNxBsLZX!AE-R<}2b98**a7T$y=|d2xz0g-3hwG0gIUN}P%Od&qrryIuuDtX_Vt z8U>|7-;IZ^Lj(#26pbnuI)|};qY`0rfYZzKF?`i#-@gt>#&Ff=peLnw40-Kx$V0bQ zc(i@X>!6CxFf81n+#|}9`apx?Ikp?ulu4qBqDk&$)>07)V$c*Bs>ZGLh_$fz@QG=D z?&+9WChn;c6Xrz^!1sy?J~6@1jTiCJ=?a4xIn0LDI4im7usd+&NsUDz1pK2sjY%7bjb7LLtC$lNv9FBK}6GZOh+Qzq6{3B~iodNHv zJJ@fE9s8vJW9fIo?`}H`-_hOH&A;{?G5jr!wH@Id1Fy+|CV}&h0Qi$2Zvn#bBZ0#zJuV3{5>$gpkUBu>k|0q){+a}N z1`r>}D$3S{DDv)fm|B3RL)*~h16jJ?7y*}-N7ms!G#^Qbb#auPMe^dPOC!u07h8_g zF%CXs&3)#(2NQ95RRpLljLS+nOTNVlZbt4-q0D;bbQHm-`{Z|>zer#YHz<2jD6=Le z^Xy5XOhL)%SOK3rcRRe>6O>B~$^%j;vv*3SJRpU#SK{o1Pcl;%>_Nw5rf`Nq*$c`n zGfcb<2x?8mQ{3d(?KT|D1}6FVr_Srq1kKnZMqJ!*kZjhVmeQ?d zVYlIcVm?dm*(ZPShXmzTgR1BdP>o7caW!2XtzE^c>7rVLG1 zFUoe?9mpNsvSHV~k)ZqogEF@}BvT#&++?2Bb_Z*VyI5RU^``{og9hasP)=^km!(k7NufMU;&g%rTlJ{352J}l z?s507L3x;@Y;Ndj0hDja`csI2_9kA4L)hVHms=rdX_|HxR~&~kT5Y)%B5Nj}$8p9K zpl(ubASAggzDP(?{TY^$E>7Z|4vuQ<2Y)#2H}53U^`VijT$wIwTjs)7GUZ%JISbvw zEj(g$c@y@uFI>5JiD_7}XnF9KF}K_jw=Ch=8w*$Q>2e$r8VnW(i`AQp8}KcY&+zV| zJ0h#Y^@|fR%lOEPGzpPsovt?G!NJJ=MK#G<*y@{b|Bxl=h5hHapQt9;{xQL<0O5Wi z8}>r=^=6^+!#Vx1B1$f6;{~JSxz`8JziL2fUt~Pd!V3{oqVSR;vVwb+v4xV=d!zdC@?igP{N!wTNTS+2r8Y!aDaY${+%Rf%@eS#1gOZ>) z|D~W{{P^+sA2((U*4^Q_A8CO0y(@k*Wf7VZn>1az{YX2}WRslDex#rF!V9K3k(Ogw zz0ufBnszn=j{%RT&C-!{Iva_r0N>kBdeqIG=!4!Bp!Y#P=~1A}!$oJuAL(6h;7CMx zcIo9rsIC`16x8Q-VlGVTaIWC_*+>{?7`U)~e1skhVD`p|o~NZ5XOj(v&F>N9N36}9 z>V&!gss~7I#Fv5(?##X891r7r$6e6+mc(!tTrgkKbm4eHoJC@sK*xGPXC4wjkx;2g zVJEH+Y;d8#prYhqwchR)S$ti@XL-@FJn07Evc5Mc={>n5l=eM}5dXuIHOr@}S&0%K z)Beq)B`+mXL~(^qStnbET0Ti0YVGWd&D{OqmboJnlqoRLozJmlX8u3E=f6<7vdCG+2Qu7fKw-DTx?M+rtH%&wr{kRB5UL!Acg2F zeMQ@LBS#b4HnO)Kj2>JfYW$%t&fnN*{8FDz-Gb6%vC7by8#gSyIQU$0&P5)5+nac^ zq$Y3GP`M$FCQ{f#HA@~91b%qxIfjJ_*KMBJQ!e5c49{!AjT&XbT)H9(l#ww#v-@>g_`UKZ(H7IZFY|0Gt za9hWInK9;Ru543uW-3{%|D9tS`=VrLozknZjg^Xhk0bv&Xt9wD>5Rr~jBNxl)ylDd zrz=pm@O$_8e7k?+pIPpIdikmRMC|1Th~p{Ts;&#}{HgLdTJ8h#bj& ziN2v!rZoLXb|FukJc@XD;^gm*O2gVAM+%G5o2;}Ig+Ng~XLD+3ze zLDc%fu}-EN@%T6w-c=SnyAf&xa7rwAcJw9#XPO1ij$RdT>MeNb=rw@9l?D!i(%I2_ z8+gC(gWh0d#A)C-sSSl=zSz;b1UQ#l@Y3OSbz;{7mi_E_-j=yd|;O$#3L4-M?^ok3nuiRMC{ zI9d2E4xFqNp?;q@*?>~&ec~ixy-%FHnI}&2!5k&_)QFpL;$(ZscY;Ou&IxHWm4gHR zM5sc9ri)Oe2vtE05TQB|Y7n7$BD7qD7Kl)z2-V{Rz+Z<7!a|y!m=jv#AW2%}`Q%P^$MKvkhrO|-c%)SYNDMD``H`n6{i)Hb6}kxc>y7YX>Eyp@BgYKqz0hUsj=5I zOEt6t{^*${k*lI-mPT@;XTBOKOM6=1scYjxpm8MqWY9~Til8eA)j0XkrEXi+Tmmbd zb|B8FeVO?o&tk_Biicdq`;X)PuG!IMe8k{#$d6(TO-l7`1dCaeD9tnP^lef=!oig4 zBR3vMNZF`5xBC-;e~~fjt%Q_Q?#mV zP(g&cc*IDe;Mi%>nVOFP!dV)u`e~OHeU;*w)-*_;B6Dy!b1;uN_(eSnHdsUPP|wzD z<>@C`x(9pbDey*MYfj_V?bBIe)BH7++*GgbmgRtn){i2?X!x9)y~kNui$d)A7f9IA zE=TJ}O@EvVTbeFLyMZ2@OLNLvdL6>1%q!(aGFG0#nA>D5^O{;u43YC-73GWcDb;eysLeXf&ivX9_ch2FN1s@QK|?c9+R_)!Qn2%>_G6 z%QG^3l7YiNwMc7!&LBInzNBrnU`|Z(o_x+A^)Pg5!JMIbdeV^}t9-`cJvlDBCG_-h ztup9(;win~fT*-vs>SL7O}6!8*28Y&g`2MKk?u0 zI6O74vmVaZ>wrA-m_BprXVCAZxs-?W^+GX@=u@jtX{U(B(RsbzQ&U8>dESW40ELa? c^sE!i72!qq#1H9HcxovXugW=V@-F=U0;m1?_5c6? literal 0 HcmV?d00001 diff --git a/source/src/Makefile b/source/src/Makefile index f087da61..078602db 100644 --- a/source/src/Makefile +++ b/source/src/Makefile @@ -3,7 +3,7 @@ INCLUDES=-I/usr/X11R6/include -I../enet/include -I../src `sdl-config --cflags` CXXFLAGS=$(CXXOPTFLAGS) $(INCLUDES) -fsigned-char -Wall -Wno-deprecated -rdynamic PLATFORM_PREFIX=native -CLIENT_LIBS=-L/usr/X11R6/lib -L../enet -lenet `sdl-config --libs` -lSDL_image -lz -lGL -lopenal -lvorbisfile +CLIENT_LIBS=-L/usr/X11R6/lib -L../enet -lenet `sdl-config --libs` -lSDL_image -lz -lGL -lopenal -lvorbisfile -ljpeg CLIENT_OBJS= \ audiomanager.o \ packetqueue.o \ diff --git a/source/src/clientgame.cpp b/source/src/clientgame.cpp index 657695ec..fd30f3d3 100644 --- a/source/src/clientgame.cpp +++ b/source/src/clientgame.cpp @@ -390,11 +390,9 @@ void updateworld(int curtime, int lastmillis) // main game update loop // force scoreboard on and give it time to display .. showscores(true); autoscreenshotat = -1 * (lastmillis + 141); - printf("forced scoreboard on @ %d - auto-ss-@ %d\n", lastmillis, autoscreenshotat); } else if(autoscreenshotat < 0 && lastmillis > -1 * autoscreenshotat) { - printf("doing auto-ss..\n"); extern void screenshot(char *imagepath); char fmttimestr[15]; // flowtron assumes "%b" is always 3 chars (true at least for DE and EN) time_t t = time(NULL); @@ -402,8 +400,8 @@ void updateworld(int curtime, int lastmillis) // main game update loop timeinfo = localtime (&t); strftime(fmttimestr, 15, "%Y%b%d_%H%M", timeinfo); // 14 + "\0" extern string smapname; - s_sprintfd(endscoreshot)("screenshots/%s_%s_%s.bmp", modestr(gamemode, true), behindpath(clientmap), fmttimestr); - printf("auto-ss-name : %s\n", endscoreshot); + extern int screenshottype; + s_sprintfd(endscoreshot)("screenshots/%s_%s_%s.%s", modestr(gamemode, true), behindpath(clientmap), fmttimestr, screenshottype ? "jpg" : "bmp"); screenshot(endscoreshot); autoscreenshotat = 0; } diff --git a/source/src/main.cpp b/source/src/main.cpp index a7358092..89ad97c7 100644 --- a/source/src/main.cpp +++ b/source/src/main.cpp @@ -138,7 +138,83 @@ void setprocesspriority(bool high) } #endif -void screenshot(char *imagepath) +VARP(screenshottype, 0, 1, 1); +VARP(jpegquality, 10, 70, 100); + +void jpeg_screenshot(char *imagepath) +{ + struct jpeg_compress_struct cinfo; + struct jpeg_error_mgr jerr; + + JSAMPROW row_pointer[1]; + JSAMPLE *image_buffer; + + int row_stride; + + if(!imagepath[0]) + { + static string buf; + time_t rawtime; + struct tm * timeinfo; + char buffer [80]; + time (&rawtime); + timeinfo = localtime (&rawtime); + strftime (buffer,80,"%Y%b%d_%H%M%S",timeinfo); + s_sprintf(buf)("screenshots/%s.jpg", buffer); + imagepath = buf; + } + FILE *jpegfile; + + if((jpegfile = fopen(imagepath, "wb")) != NULL) + { + cinfo.err = jpeg_std_error(&jerr); + jpeg_create_compress(&cinfo); + jpeg_stdio_dest(&cinfo, jpegfile); + + GLubyte *pixels = new GLubyte[ 3*scr_w*scr_h*sizeof(GLubyte)]; + GLubyte *flip = new GLubyte[ 3*scr_w*scr_h*sizeof(GLubyte)]; + + image_buffer = pixels; + if (pixels!=NULL && flip!=NULL) + { + glPixelStorei(GL_PACK_ALIGNMENT, 1); + glReadBuffer(GL_BACK); + glReadPixels(0, 0, scr_w, scr_h, GL_RGB, GL_UNSIGNED_BYTE, pixels); + + cinfo.image_width = scr_w; + cinfo.image_height = scr_h; + cinfo.input_components = 3; + cinfo.in_color_space = JCS_RGB; + + jpeg_set_defaults(&cinfo); + jpeg_set_quality(&cinfo, jpegquality, TRUE); + jpeg_start_compress(&cinfo, TRUE); + + for (int y=0;yw, screen->h, 24, 0x0000FF, 0x00FF00, 0xFF0000, 0); if(!image) return; @@ -164,6 +240,16 @@ void screenshot(char *imagepath) SDL_FreeSurface(image); } +void screenshot(char *imagepath) +{ + switch(screenshottype) + { + case 1: jpeg_screenshot(imagepath); break; + case 0: + default: bmp_screenshot(imagepath); break; + } +} + COMMAND(screenshot, ARG_1STR); COMMAND(quit, ARG_NONE); diff --git a/source/src/pch.h b/source/src/pch.h index 0c197a21..8c508420 100644 --- a/source/src/pch.h +++ b/source/src/pch.h @@ -64,3 +64,4 @@ #include "vorbis/vorbisfile.h" #endif +#include