From 7096683d2421aafc0cac708949900c1e4c94e4b2 Mon Sep 17 00:00:00 2001 From: "alexey.lysiuk" Date: Wed, 23 Jun 2021 10:19:20 +0300 Subject: [PATCH] add freeimage 3.18.0 --- deps/freeimage/include/FreeImage.h | 1163 +++++++++++++++++++++ deps/freeimage/lib/libfreeimage.a | Bin 0 -> 20182232 bytes deps/freeimage/lib/pkgconfig/freeimage.pc | 13 + 3 files changed, 1176 insertions(+) create mode 100644 deps/freeimage/include/FreeImage.h create mode 100644 deps/freeimage/lib/libfreeimage.a create mode 100644 deps/freeimage/lib/pkgconfig/freeimage.pc diff --git a/deps/freeimage/include/FreeImage.h b/deps/freeimage/include/FreeImage.h new file mode 100644 index 00000000..12182cd8 --- /dev/null +++ b/deps/freeimage/include/FreeImage.h @@ -0,0 +1,1163 @@ +// ========================================================== +// FreeImage 3 +// +// Design and implementation by +// - Floris van den Berg (flvdberg@wxs.nl) +// - Hervé Drolon (drolon@infonie.fr) +// +// Contributors: +// - see changes log named 'Whatsnew.txt', see header of each .h and .cpp file +// +// This file is part of FreeImage 3 +// +// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY +// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES +// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE +// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED +// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT +// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY +// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL +// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER +// THIS DISCLAIMER. +// +// Use at your own risk! +// ========================================================== + +#ifndef FREEIMAGE_H +#define FREEIMAGE_H + +// Version information ------------------------------------------------------ + +#define FREEIMAGE_MAJOR_VERSION 3 +#define FREEIMAGE_MINOR_VERSION 18 +#define FREEIMAGE_RELEASE_SERIAL 0 + +// Compiler options --------------------------------------------------------- + +#include // needed for UNICODE functions + +#if defined(FREEIMAGE_LIB) + #define DLL_API + #define DLL_CALLCONV +#else + #if defined(_WIN32) || defined(__WIN32__) + #define DLL_CALLCONV __stdcall + // The following ifdef block is the standard way of creating macros which make exporting + // from a DLL simpler. All files within this DLL are compiled with the FREEIMAGE_EXPORTS + // symbol defined on the command line. this symbol should not be defined on any project + // that uses this DLL. This way any other project whose source files include this file see + // DLL_API functions as being imported from a DLL, wheras this DLL sees symbols + // defined with this macro as being exported. + #ifdef FREEIMAGE_EXPORTS + #define DLL_API __declspec(dllexport) + #else + #define DLL_API __declspec(dllimport) + #endif // FREEIMAGE_EXPORTS + #else + // try the gcc visibility support (see http://gcc.gnu.org/wiki/Visibility) + #if defined(__GNUC__) && ((__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) + #ifndef GCC_HASCLASSVISIBILITY + #define GCC_HASCLASSVISIBILITY + #endif + #endif // __GNUC__ + #define DLL_CALLCONV + #if defined(GCC_HASCLASSVISIBILITY) + #define DLL_API __attribute__ ((visibility("default"))) + #else + #define DLL_API + #endif + #endif // WIN32 / !WIN32 +#endif // FREEIMAGE_LIB + +// Endianness: +// Some versions of gcc may have BYTE_ORDER or __BYTE_ORDER defined. +// If your big endian system isn't being detected, add an OS specific check +// or define any of FREEIMAGE_BIGENDIAN and FREEIMAGE_LITTLEENDIAN directly +// to specify the desired endianness. +#if (!defined(FREEIMAGE_BIGENDIAN) && !defined(FREEIMAGE_LITTLEENDIAN)) +#if (defined(BYTE_ORDER) && BYTE_ORDER==BIG_ENDIAN) || (defined(__BYTE_ORDER) && __BYTE_ORDER==__BIG_ENDIAN) || (defined(__BYTE_ORDER) && __BYTE_ORDER==__ORDER_BIG_ENDIAN__) || defined(__BIG_ENDIAN__) + #define FREEIMAGE_BIGENDIAN + #endif // BYTE_ORDER +#endif // !FREEIMAGE_[BIG|LITTLE]ENDIAN + +// Color-Order: +// The specified order of color components red, green and blue affects 24- +// and 32-bit images of type FIT_BITMAP as well as the colors that are part +// of a color palette. All other images always use RGB order. By default, +// color order is coupled to endianness: +// little-endian -> BGR +// big-endian -> RGB +// However, you can always define FREEIMAGE_COLORORDER to any of the known +// orders FREEIMAGE_COLORORDER_BGR (0) and FREEIMAGE_COLORORDER_RGB (1) to +// specify your preferred color order. +#define FREEIMAGE_COLORORDER_BGR 0 +#define FREEIMAGE_COLORORDER_RGB 1 +#if (!defined(FREEIMAGE_COLORORDER)) || ((FREEIMAGE_COLORORDER != FREEIMAGE_COLORORDER_BGR) && (FREEIMAGE_COLORORDER != FREEIMAGE_COLORORDER_RGB)) + #if defined(FREEIMAGE_BIGENDIAN) + #define FREEIMAGE_COLORORDER FREEIMAGE_COLORORDER_RGB + #else + #define FREEIMAGE_COLORORDER FREEIMAGE_COLORORDER_BGR + #endif // FREEIMAGE_BIGENDIAN +#endif // FREEIMAGE_COLORORDER + +// Ensure 4-byte enums if we're using Borland C++ compilers +#if defined(__BORLANDC__) +#pragma option push -b +#endif + +// For C compatibility -------------------------------------------------------- + +#ifdef __cplusplus +#define FI_DEFAULT(x) = x +#define FI_ENUM(x) enum x +#define FI_STRUCT(x) struct x +#else +#define FI_DEFAULT(x) +#define FI_ENUM(x) typedef int x; enum x +#define FI_STRUCT(x) typedef struct x x; struct x +#endif + +// Bitmap types ------------------------------------------------------------- + +FI_STRUCT (FIBITMAP) { void *data; }; +FI_STRUCT (FIMULTIBITMAP) { void *data; }; + +// Types used in the library (directly copied from Windows) ----------------- + +#if defined(__MINGW32__) && defined(_WINDOWS_H) +#define _WINDOWS_ // prevent a bug in MinGW32 +#endif // __MINGW32__ + +#ifndef _WINDOWS_ +#define _WINDOWS_ + +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef TRUE +#define TRUE 1 +#endif +#ifndef NULL +#define NULL 0 +#endif + +#ifndef SEEK_SET +#define SEEK_SET 0 +#define SEEK_CUR 1 +#define SEEK_END 2 +#endif + +#ifndef _MSC_VER +// define portable types for 32-bit / 64-bit OS +#include +typedef int32_t BOOL; +typedef uint8_t BYTE; +typedef uint16_t WORD; +typedef uint32_t DWORD; +typedef int32_t LONG; +typedef int64_t INT64; +typedef uint64_t UINT64; +#else +// MS is not C99 ISO compliant +typedef long BOOL; +typedef unsigned char BYTE; +typedef unsigned short WORD; +typedef unsigned long DWORD; +typedef long LONG; +typedef signed __int64 INT64; +typedef unsigned __int64 UINT64; +#endif // _MSC_VER + +#if (defined(_WIN32) || defined(__WIN32__)) +#pragma pack(push, 1) +#else +#pragma pack(1) +#endif // WIN32 + +typedef struct tagRGBQUAD { +#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR + BYTE rgbBlue; + BYTE rgbGreen; + BYTE rgbRed; +#else + BYTE rgbRed; + BYTE rgbGreen; + BYTE rgbBlue; +#endif // FREEIMAGE_COLORORDER + BYTE rgbReserved; +} RGBQUAD; + +typedef struct tagRGBTRIPLE { +#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR + BYTE rgbtBlue; + BYTE rgbtGreen; + BYTE rgbtRed; +#else + BYTE rgbtRed; + BYTE rgbtGreen; + BYTE rgbtBlue; +#endif // FREEIMAGE_COLORORDER +} RGBTRIPLE; + +#if (defined(_WIN32) || defined(__WIN32__)) +#pragma pack(pop) +#else +#pragma pack() +#endif // WIN32 + +typedef struct tagBITMAPINFOHEADER{ + DWORD biSize; + LONG biWidth; + LONG biHeight; + WORD biPlanes; + WORD biBitCount; + DWORD biCompression; + DWORD biSizeImage; + LONG biXPelsPerMeter; + LONG biYPelsPerMeter; + DWORD biClrUsed; + DWORD biClrImportant; +} BITMAPINFOHEADER, *PBITMAPINFOHEADER; + +typedef struct tagBITMAPINFO { + BITMAPINFOHEADER bmiHeader; + RGBQUAD bmiColors[1]; +} BITMAPINFO, *PBITMAPINFO; + +#endif // _WINDOWS_ + +// Types used in the library (specific to FreeImage) ------------------------ + +#if (defined(_WIN32) || defined(__WIN32__)) +#pragma pack(push, 1) +#else +#pragma pack(1) +#endif // WIN32 + +/** 48-bit RGB +*/ +typedef struct tagFIRGB16 { + WORD red; + WORD green; + WORD blue; +} FIRGB16; + +/** 64-bit RGBA +*/ +typedef struct tagFIRGBA16 { + WORD red; + WORD green; + WORD blue; + WORD alpha; +} FIRGBA16; + +/** 96-bit RGB Float +*/ +typedef struct tagFIRGBF { + float red; + float green; + float blue; +} FIRGBF; + +/** 128-bit RGBA Float +*/ +typedef struct tagFIRGBAF { + float red; + float green; + float blue; + float alpha; +} FIRGBAF; + +/** Data structure for COMPLEX type (complex number) +*/ +typedef struct tagFICOMPLEX { + /// real part + double r; + /// imaginary part + double i; +} FICOMPLEX; + +#if (defined(_WIN32) || defined(__WIN32__)) +#pragma pack(pop) +#else +#pragma pack() +#endif // WIN32 + +// Indexes for byte arrays, masks and shifts for treating pixels as words --- +// These coincide with the order of RGBQUAD and RGBTRIPLE ------------------- + +#ifndef FREEIMAGE_BIGENDIAN +#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR +// Little Endian (x86 / MS Windows, Linux) : BGR(A) order +#define FI_RGBA_RED 2 +#define FI_RGBA_GREEN 1 +#define FI_RGBA_BLUE 0 +#define FI_RGBA_ALPHA 3 +#define FI_RGBA_RED_MASK 0x00FF0000 +#define FI_RGBA_GREEN_MASK 0x0000FF00 +#define FI_RGBA_BLUE_MASK 0x000000FF +#define FI_RGBA_ALPHA_MASK 0xFF000000 +#define FI_RGBA_RED_SHIFT 16 +#define FI_RGBA_GREEN_SHIFT 8 +#define FI_RGBA_BLUE_SHIFT 0 +#define FI_RGBA_ALPHA_SHIFT 24 +#else +// Little Endian (x86 / MaxOSX) : RGB(A) order +#define FI_RGBA_RED 0 +#define FI_RGBA_GREEN 1 +#define FI_RGBA_BLUE 2 +#define FI_RGBA_ALPHA 3 +#define FI_RGBA_RED_MASK 0x000000FF +#define FI_RGBA_GREEN_MASK 0x0000FF00 +#define FI_RGBA_BLUE_MASK 0x00FF0000 +#define FI_RGBA_ALPHA_MASK 0xFF000000 +#define FI_RGBA_RED_SHIFT 0 +#define FI_RGBA_GREEN_SHIFT 8 +#define FI_RGBA_BLUE_SHIFT 16 +#define FI_RGBA_ALPHA_SHIFT 24 +#endif // FREEIMAGE_COLORORDER +#else +#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR +// Big Endian (PPC / none) : BGR(A) order +#define FI_RGBA_RED 2 +#define FI_RGBA_GREEN 1 +#define FI_RGBA_BLUE 0 +#define FI_RGBA_ALPHA 3 +#define FI_RGBA_RED_MASK 0x0000FF00 +#define FI_RGBA_GREEN_MASK 0x00FF0000 +#define FI_RGBA_BLUE_MASK 0xFF000000 +#define FI_RGBA_ALPHA_MASK 0x000000FF +#define FI_RGBA_RED_SHIFT 8 +#define FI_RGBA_GREEN_SHIFT 16 +#define FI_RGBA_BLUE_SHIFT 24 +#define FI_RGBA_ALPHA_SHIFT 0 +#else +// Big Endian (PPC / Linux, MaxOSX) : RGB(A) order +#define FI_RGBA_RED 0 +#define FI_RGBA_GREEN 1 +#define FI_RGBA_BLUE 2 +#define FI_RGBA_ALPHA 3 +#define FI_RGBA_RED_MASK 0xFF000000 +#define FI_RGBA_GREEN_MASK 0x00FF0000 +#define FI_RGBA_BLUE_MASK 0x0000FF00 +#define FI_RGBA_ALPHA_MASK 0x000000FF +#define FI_RGBA_RED_SHIFT 24 +#define FI_RGBA_GREEN_SHIFT 16 +#define FI_RGBA_BLUE_SHIFT 8 +#define FI_RGBA_ALPHA_SHIFT 0 +#endif // FREEIMAGE_COLORORDER +#endif // FREEIMAGE_BIGENDIAN + +#define FI_RGBA_RGB_MASK (FI_RGBA_RED_MASK|FI_RGBA_GREEN_MASK|FI_RGBA_BLUE_MASK) + +// The 16bit macros only include masks and shifts, since each color element is not byte aligned + +#define FI16_555_RED_MASK 0x7C00 +#define FI16_555_GREEN_MASK 0x03E0 +#define FI16_555_BLUE_MASK 0x001F +#define FI16_555_RED_SHIFT 10 +#define FI16_555_GREEN_SHIFT 5 +#define FI16_555_BLUE_SHIFT 0 +#define FI16_565_RED_MASK 0xF800 +#define FI16_565_GREEN_MASK 0x07E0 +#define FI16_565_BLUE_MASK 0x001F +#define FI16_565_RED_SHIFT 11 +#define FI16_565_GREEN_SHIFT 5 +#define FI16_565_BLUE_SHIFT 0 + +// ICC profile support ------------------------------------------------------ + +#define FIICC_DEFAULT 0x00 +#define FIICC_COLOR_IS_CMYK 0x01 + +FI_STRUCT (FIICCPROFILE) { + WORD flags; //! info flag + DWORD size; //! profile's size measured in bytes + void *data; //! points to a block of contiguous memory containing the profile +}; + +// Important enums ---------------------------------------------------------- + +/** I/O image format identifiers. +*/ +FI_ENUM(FREE_IMAGE_FORMAT) { + FIF_UNKNOWN = -1, + FIF_BMP = 0, + FIF_ICO = 1, + FIF_JPEG = 2, + FIF_JNG = 3, + FIF_KOALA = 4, + FIF_LBM = 5, + FIF_IFF = FIF_LBM, + FIF_MNG = 6, + FIF_PBM = 7, + FIF_PBMRAW = 8, + FIF_PCD = 9, + FIF_PCX = 10, + FIF_PGM = 11, + FIF_PGMRAW = 12, + FIF_PNG = 13, + FIF_PPM = 14, + FIF_PPMRAW = 15, + FIF_RAS = 16, + FIF_TARGA = 17, + FIF_TIFF = 18, + FIF_WBMP = 19, + FIF_PSD = 20, + FIF_CUT = 21, + FIF_XBM = 22, + FIF_XPM = 23, + FIF_DDS = 24, + FIF_GIF = 25, + FIF_HDR = 26, + FIF_FAXG3 = 27, + FIF_SGI = 28, + FIF_EXR = 29, + FIF_J2K = 30, + FIF_JP2 = 31, + FIF_PFM = 32, + FIF_PICT = 33, + FIF_RAW = 34, + FIF_WEBP = 35, + FIF_JXR = 36 +}; + +/** Image type used in FreeImage. +*/ +FI_ENUM(FREE_IMAGE_TYPE) { + FIT_UNKNOWN = 0, //! unknown type + FIT_BITMAP = 1, //! standard image : 1-, 4-, 8-, 16-, 24-, 32-bit + FIT_UINT16 = 2, //! array of unsigned short : unsigned 16-bit + FIT_INT16 = 3, //! array of short : signed 16-bit + FIT_UINT32 = 4, //! array of unsigned long : unsigned 32-bit + FIT_INT32 = 5, //! array of long : signed 32-bit + FIT_FLOAT = 6, //! array of float : 32-bit IEEE floating point + FIT_DOUBLE = 7, //! array of double : 64-bit IEEE floating point + FIT_COMPLEX = 8, //! array of FICOMPLEX : 2 x 64-bit IEEE floating point + FIT_RGB16 = 9, //! 48-bit RGB image : 3 x 16-bit + FIT_RGBA16 = 10, //! 64-bit RGBA image : 4 x 16-bit + FIT_RGBF = 11, //! 96-bit RGB float image : 3 x 32-bit IEEE floating point + FIT_RGBAF = 12 //! 128-bit RGBA float image : 4 x 32-bit IEEE floating point +}; + +/** Image color type used in FreeImage. +*/ +FI_ENUM(FREE_IMAGE_COLOR_TYPE) { + FIC_MINISWHITE = 0, //! min value is white + FIC_MINISBLACK = 1, //! min value is black + FIC_RGB = 2, //! RGB color model + FIC_PALETTE = 3, //! color map indexed + FIC_RGBALPHA = 4, //! RGB color model with alpha channel + FIC_CMYK = 5 //! CMYK color model +}; + +/** Color quantization algorithms. +Constants used in FreeImage_ColorQuantize. +*/ +FI_ENUM(FREE_IMAGE_QUANTIZE) { + FIQ_WUQUANT = 0, //! Xiaolin Wu color quantization algorithm + FIQ_NNQUANT = 1, //! NeuQuant neural-net quantization algorithm by Anthony Dekker + FIQ_LFPQUANT = 2 //! Lossless Fast Pseudo-Quantization Algorithm by Carsten Klein +}; + +/** Dithering algorithms. +Constants used in FreeImage_Dither. +*/ +FI_ENUM(FREE_IMAGE_DITHER) { + FID_FS = 0, //! Floyd & Steinberg error diffusion + FID_BAYER4x4 = 1, //! Bayer ordered dispersed dot dithering (order 2 dithering matrix) + FID_BAYER8x8 = 2, //! Bayer ordered dispersed dot dithering (order 3 dithering matrix) + FID_CLUSTER6x6 = 3, //! Ordered clustered dot dithering (order 3 - 6x6 matrix) + FID_CLUSTER8x8 = 4, //! Ordered clustered dot dithering (order 4 - 8x8 matrix) + FID_CLUSTER16x16= 5, //! Ordered clustered dot dithering (order 8 - 16x16 matrix) + FID_BAYER16x16 = 6 //! Bayer ordered dispersed dot dithering (order 4 dithering matrix) +}; + +/** Lossless JPEG transformations +Constants used in FreeImage_JPEGTransform +*/ +FI_ENUM(FREE_IMAGE_JPEG_OPERATION) { + FIJPEG_OP_NONE = 0, //! no transformation + FIJPEG_OP_FLIP_H = 1, //! horizontal flip + FIJPEG_OP_FLIP_V = 2, //! vertical flip + FIJPEG_OP_TRANSPOSE = 3, //! transpose across UL-to-LR axis + FIJPEG_OP_TRANSVERSE = 4, //! transpose across UR-to-LL axis + FIJPEG_OP_ROTATE_90 = 5, //! 90-degree clockwise rotation + FIJPEG_OP_ROTATE_180 = 6, //! 180-degree rotation + FIJPEG_OP_ROTATE_270 = 7 //! 270-degree clockwise (or 90 ccw) +}; + +/** Tone mapping operators. +Constants used in FreeImage_ToneMapping. +*/ +FI_ENUM(FREE_IMAGE_TMO) { + FITMO_DRAGO03 = 0, //! Adaptive logarithmic mapping (F. Drago, 2003) + FITMO_REINHARD05 = 1, //! Dynamic range reduction inspired by photoreceptor physiology (E. Reinhard, 2005) + FITMO_FATTAL02 = 2 //! Gradient domain high dynamic range compression (R. Fattal, 2002) +}; + +/** Upsampling / downsampling filters. +Constants used in FreeImage_Rescale. +*/ +FI_ENUM(FREE_IMAGE_FILTER) { + FILTER_BOX = 0, //! Box, pulse, Fourier window, 1st order (constant) b-spline + FILTER_BICUBIC = 1, //! Mitchell & Netravali's two-param cubic filter + FILTER_BILINEAR = 2, //! Bilinear filter + FILTER_BSPLINE = 3, //! 4th order (cubic) b-spline + FILTER_CATMULLROM = 4, //! Catmull-Rom spline, Overhauser spline + FILTER_LANCZOS3 = 5 //! Lanczos3 filter +}; + +/** Color channels. +Constants used in color manipulation routines. +*/ +FI_ENUM(FREE_IMAGE_COLOR_CHANNEL) { + FICC_RGB = 0, //! Use red, green and blue channels + FICC_RED = 1, //! Use red channel + FICC_GREEN = 2, //! Use green channel + FICC_BLUE = 3, //! Use blue channel + FICC_ALPHA = 4, //! Use alpha channel + FICC_BLACK = 5, //! Use black channel + FICC_REAL = 6, //! Complex images: use real part + FICC_IMAG = 7, //! Complex images: use imaginary part + FICC_MAG = 8, //! Complex images: use magnitude + FICC_PHASE = 9 //! Complex images: use phase +}; + +// Metadata support --------------------------------------------------------- + +/** + Tag data type information (based on TIFF specifications) + + Note: RATIONALs are the ratio of two 32-bit integer values. +*/ +FI_ENUM(FREE_IMAGE_MDTYPE) { + FIDT_NOTYPE = 0, //! placeholder + FIDT_BYTE = 1, //! 8-bit unsigned integer + FIDT_ASCII = 2, //! 8-bit bytes w/ last byte null + FIDT_SHORT = 3, //! 16-bit unsigned integer + FIDT_LONG = 4, //! 32-bit unsigned integer + FIDT_RATIONAL = 5, //! 64-bit unsigned fraction + FIDT_SBYTE = 6, //! 8-bit signed integer + FIDT_UNDEFINED = 7, //! 8-bit untyped data + FIDT_SSHORT = 8, //! 16-bit signed integer + FIDT_SLONG = 9, //! 32-bit signed integer + FIDT_SRATIONAL = 10, //! 64-bit signed fraction + FIDT_FLOAT = 11, //! 32-bit IEEE floating point + FIDT_DOUBLE = 12, //! 64-bit IEEE floating point + FIDT_IFD = 13, //! 32-bit unsigned integer (offset) + FIDT_PALETTE = 14, //! 32-bit RGBQUAD + FIDT_LONG8 = 16, //! 64-bit unsigned integer + FIDT_SLONG8 = 17, //! 64-bit signed integer + FIDT_IFD8 = 18 //! 64-bit unsigned integer (offset) +}; + +/** + Metadata models supported by FreeImage +*/ +FI_ENUM(FREE_IMAGE_MDMODEL) { + FIMD_NODATA = -1, + FIMD_COMMENTS = 0, //! single comment or keywords + FIMD_EXIF_MAIN = 1, //! Exif-TIFF metadata + FIMD_EXIF_EXIF = 2, //! Exif-specific metadata + FIMD_EXIF_GPS = 3, //! Exif GPS metadata + FIMD_EXIF_MAKERNOTE = 4, //! Exif maker note metadata + FIMD_EXIF_INTEROP = 5, //! Exif interoperability metadata + FIMD_IPTC = 6, //! IPTC/NAA metadata + FIMD_XMP = 7, //! Abobe XMP metadata + FIMD_GEOTIFF = 8, //! GeoTIFF metadata + FIMD_ANIMATION = 9, //! Animation metadata + FIMD_CUSTOM = 10, //! Used to attach other metadata types to a dib + FIMD_EXIF_RAW = 11 //! Exif metadata as a raw buffer +}; + +/** + Handle to a metadata model +*/ +FI_STRUCT (FIMETADATA) { void *data; }; + +/** + Handle to a FreeImage tag +*/ +FI_STRUCT (FITAG) { void *data; }; + +// File IO routines --------------------------------------------------------- + +#ifndef FREEIMAGE_IO +#define FREEIMAGE_IO + +typedef void* fi_handle; +typedef unsigned (DLL_CALLCONV *FI_ReadProc) (void *buffer, unsigned size, unsigned count, fi_handle handle); +typedef unsigned (DLL_CALLCONV *FI_WriteProc) (void *buffer, unsigned size, unsigned count, fi_handle handle); +typedef int (DLL_CALLCONV *FI_SeekProc) (fi_handle handle, long offset, int origin); +typedef long (DLL_CALLCONV *FI_TellProc) (fi_handle handle); + +#if (defined(_WIN32) || defined(__WIN32__)) +#pragma pack(push, 1) +#else +#pragma pack(1) +#endif // WIN32 + +FI_STRUCT(FreeImageIO) { + FI_ReadProc read_proc; //! pointer to the function used to read data + FI_WriteProc write_proc; //! pointer to the function used to write data + FI_SeekProc seek_proc; //! pointer to the function used to seek + FI_TellProc tell_proc; //! pointer to the function used to aquire the current position +}; + +#if (defined(_WIN32) || defined(__WIN32__)) +#pragma pack(pop) +#else +#pragma pack() +#endif // WIN32 + +/** +Handle to a memory I/O stream +*/ +FI_STRUCT (FIMEMORY) { void *data; }; + +#endif // FREEIMAGE_IO + +// Plugin routines ---------------------------------------------------------- + +#ifndef PLUGINS +#define PLUGINS + +typedef const char *(DLL_CALLCONV *FI_FormatProc)(void); +typedef const char *(DLL_CALLCONV *FI_DescriptionProc)(void); +typedef const char *(DLL_CALLCONV *FI_ExtensionListProc)(void); +typedef const char *(DLL_CALLCONV *FI_RegExprProc)(void); +typedef void *(DLL_CALLCONV *FI_OpenProc)(FreeImageIO *io, fi_handle handle, BOOL read); +typedef void (DLL_CALLCONV *FI_CloseProc)(FreeImageIO *io, fi_handle handle, void *data); +typedef int (DLL_CALLCONV *FI_PageCountProc)(FreeImageIO *io, fi_handle handle, void *data); +typedef int (DLL_CALLCONV *FI_PageCapabilityProc)(FreeImageIO *io, fi_handle handle, void *data); +typedef FIBITMAP *(DLL_CALLCONV *FI_LoadProc)(FreeImageIO *io, fi_handle handle, int page, int flags, void *data); +typedef BOOL (DLL_CALLCONV *FI_SaveProc)(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data); +typedef BOOL (DLL_CALLCONV *FI_ValidateProc)(FreeImageIO *io, fi_handle handle); +typedef const char *(DLL_CALLCONV *FI_MimeProc)(void); +typedef BOOL (DLL_CALLCONV *FI_SupportsExportBPPProc)(int bpp); +typedef BOOL (DLL_CALLCONV *FI_SupportsExportTypeProc)(FREE_IMAGE_TYPE type); +typedef BOOL (DLL_CALLCONV *FI_SupportsICCProfilesProc)(void); +typedef BOOL (DLL_CALLCONV *FI_SupportsNoPixelsProc)(void); + +FI_STRUCT (Plugin) { + FI_FormatProc format_proc; + FI_DescriptionProc description_proc; + FI_ExtensionListProc extension_proc; + FI_RegExprProc regexpr_proc; + FI_OpenProc open_proc; + FI_CloseProc close_proc; + FI_PageCountProc pagecount_proc; + FI_PageCapabilityProc pagecapability_proc; + FI_LoadProc load_proc; + FI_SaveProc save_proc; + FI_ValidateProc validate_proc; + FI_MimeProc mime_proc; + FI_SupportsExportBPPProc supports_export_bpp_proc; + FI_SupportsExportTypeProc supports_export_type_proc; + FI_SupportsICCProfilesProc supports_icc_profiles_proc; + FI_SupportsNoPixelsProc supports_no_pixels_proc; +}; + +typedef void (DLL_CALLCONV *FI_InitProc)(Plugin *plugin, int format_id); + +#endif // PLUGINS + + +// Load / Save flag constants ----------------------------------------------- + +#define FIF_LOAD_NOPIXELS 0x8000 //! loading: load the image header only (not supported by all plugins, default to full loading) + +#define BMP_DEFAULT 0 +#define BMP_SAVE_RLE 1 +#define CUT_DEFAULT 0 +#define DDS_DEFAULT 0 +#define EXR_DEFAULT 0 //! save data as half with piz-based wavelet compression +#define EXR_FLOAT 0x0001 //! save data as float instead of as half (not recommended) +#define EXR_NONE 0x0002 //! save with no compression +#define EXR_ZIP 0x0004 //! save with zlib compression, in blocks of 16 scan lines +#define EXR_PIZ 0x0008 //! save with piz-based wavelet compression +#define EXR_PXR24 0x0010 //! save with lossy 24-bit float compression +#define EXR_B44 0x0020 //! save with lossy 44% float compression - goes to 22% when combined with EXR_LC +#define EXR_LC 0x0040 //! save images with one luminance and two chroma channels, rather than as RGB (lossy compression) +#define FAXG3_DEFAULT 0 +#define GIF_DEFAULT 0 +#define GIF_LOAD256 1 //! load the image as a 256 color image with ununsed palette entries, if it's 16 or 2 color +#define GIF_PLAYBACK 2 //! 'Play' the GIF to generate each frame (as 32bpp) instead of returning raw frame data when loading +#define HDR_DEFAULT 0 +#define ICO_DEFAULT 0 +#define ICO_MAKEALPHA 1 //! convert to 32bpp and create an alpha channel from the AND-mask when loading +#define IFF_DEFAULT 0 +#define J2K_DEFAULT 0 //! save with a 16:1 rate +#define JP2_DEFAULT 0 //! save with a 16:1 rate +#define JPEG_DEFAULT 0 //! loading (see JPEG_FAST); saving (see JPEG_QUALITYGOOD|JPEG_SUBSAMPLING_420) +#define JPEG_FAST 0x0001 //! load the file as fast as possible, sacrificing some quality +#define JPEG_ACCURATE 0x0002 //! load the file with the best quality, sacrificing some speed +#define JPEG_CMYK 0x0004 //! load separated CMYK "as is" (use | to combine with other load flags) +#define JPEG_EXIFROTATE 0x0008 //! load and rotate according to Exif 'Orientation' tag if available +#define JPEG_GREYSCALE 0x0010 //! load and convert to a 8-bit greyscale image +#define JPEG_QUALITYSUPERB 0x80 //! save with superb quality (100:1) +#define JPEG_QUALITYGOOD 0x0100 //! save with good quality (75:1) +#define JPEG_QUALITYNORMAL 0x0200 //! save with normal quality (50:1) +#define JPEG_QUALITYAVERAGE 0x0400 //! save with average quality (25:1) +#define JPEG_QUALITYBAD 0x0800 //! save with bad quality (10:1) +#define JPEG_PROGRESSIVE 0x2000 //! save as a progressive-JPEG (use | to combine with other save flags) +#define JPEG_SUBSAMPLING_411 0x1000 //! save with high 4x1 chroma subsampling (4:1:1) +#define JPEG_SUBSAMPLING_420 0x4000 //! save with medium 2x2 medium chroma subsampling (4:2:0) - default value +#define JPEG_SUBSAMPLING_422 0x8000 //! save with low 2x1 chroma subsampling (4:2:2) +#define JPEG_SUBSAMPLING_444 0x10000 //! save with no chroma subsampling (4:4:4) +#define JPEG_OPTIMIZE 0x20000 //! on saving, compute optimal Huffman coding tables (can reduce a few percent of file size) +#define JPEG_BASELINE 0x40000 //! save basic JPEG, without metadata or any markers +#define KOALA_DEFAULT 0 +#define LBM_DEFAULT 0 +#define MNG_DEFAULT 0 +#define PCD_DEFAULT 0 +#define PCD_BASE 1 //! load the bitmap sized 768 x 512 +#define PCD_BASEDIV4 2 //! load the bitmap sized 384 x 256 +#define PCD_BASEDIV16 3 //! load the bitmap sized 192 x 128 +#define PCX_DEFAULT 0 +#define PFM_DEFAULT 0 +#define PICT_DEFAULT 0 +#define PNG_DEFAULT 0 +#define PNG_IGNOREGAMMA 1 //! loading: avoid gamma correction +#define PNG_Z_BEST_SPEED 0x0001 //! save using ZLib level 1 compression flag (default value is 6) +#define PNG_Z_DEFAULT_COMPRESSION 0x0006 //! save using ZLib level 6 compression flag (default recommended value) +#define PNG_Z_BEST_COMPRESSION 0x0009 //! save using ZLib level 9 compression flag (default value is 6) +#define PNG_Z_NO_COMPRESSION 0x0100 //! save without ZLib compression +#define PNG_INTERLACED 0x0200 //! save using Adam7 interlacing (use | to combine with other save flags) +#define PNM_DEFAULT 0 +#define PNM_SAVE_RAW 0 //! if set the writer saves in RAW format (i.e. P4, P5 or P6) +#define PNM_SAVE_ASCII 1 //! if set the writer saves in ASCII format (i.e. P1, P2 or P3) +#define PSD_DEFAULT 0 +#define PSD_CMYK 1 //! reads tags for separated CMYK (default is conversion to RGB) +#define PSD_LAB 2 //! reads tags for CIELab (default is conversion to RGB) +#define PSD_NONE 0x0100 //! save without any compression +#define PSD_RLE 0x0200 //! save using RLE compression +#define PSD_PSB 0x2000 //! save using Adobe Large Document Format (use | to combine with other save flags) +#define RAS_DEFAULT 0 +#define RAW_DEFAULT 0 //! load the file as linear RGB 48-bit +#define RAW_PREVIEW 1 //! try to load the embedded JPEG preview with included Exif Data or default to RGB 24-bit +#define RAW_DISPLAY 2 //! load the file as RGB 24-bit +#define RAW_HALFSIZE 4 //! output a half-size color image +#define RAW_UNPROCESSED 8 //! output a FIT_UINT16 raw Bayer image +#define SGI_DEFAULT 0 +#define TARGA_DEFAULT 0 +#define TARGA_LOAD_RGB888 1 //! if set the loader converts RGB555 and ARGB8888 -> RGB888. +#define TARGA_SAVE_RLE 2 //! if set, the writer saves with RLE compression +#define TIFF_DEFAULT 0 +#define TIFF_CMYK 0x0001 //! reads/stores tags for separated CMYK (use | to combine with compression flags) +#define TIFF_PACKBITS 0x0100 //! save using PACKBITS compression +#define TIFF_DEFLATE 0x0200 //! save using DEFLATE compression (a.k.a. ZLIB compression) +#define TIFF_ADOBE_DEFLATE 0x0400 //! save using ADOBE DEFLATE compression +#define TIFF_NONE 0x0800 //! save without any compression +#define TIFF_CCITTFAX3 0x1000 //! save using CCITT Group 3 fax encoding +#define TIFF_CCITTFAX4 0x2000 //! save using CCITT Group 4 fax encoding +#define TIFF_LZW 0x4000 //! save using LZW compression +#define TIFF_JPEG 0x8000 //! save using JPEG compression +#define TIFF_LOGLUV 0x10000 //! save using LogLuv compression +#define WBMP_DEFAULT 0 +#define XBM_DEFAULT 0 +#define XPM_DEFAULT 0 +#define WEBP_DEFAULT 0 //! save with good quality (75:1) +#define WEBP_LOSSLESS 0x100 //! save in lossless mode +#define JXR_DEFAULT 0 //! save with quality 80 and no chroma subsampling (4:4:4) +#define JXR_LOSSLESS 0x0064 //! save lossless +#define JXR_PROGRESSIVE 0x2000 //! save as a progressive-JXR (use | to combine with other save flags) + +// Background filling options --------------------------------------------------------- +// Constants used in FreeImage_FillBackground and FreeImage_EnlargeCanvas + +#define FI_COLOR_IS_RGB_COLOR 0x00 //! RGBQUAD color is a RGB color (contains no valid alpha channel) +#define FI_COLOR_IS_RGBA_COLOR 0x01 //! RGBQUAD color is a RGBA color (contains a valid alpha channel) +#define FI_COLOR_FIND_EQUAL_COLOR 0x02 //! For palettized images: lookup equal RGB color from palette +#define FI_COLOR_ALPHA_IS_INDEX 0x04 //! The color's rgbReserved member (alpha) contains the palette index to be used +#define FI_COLOR_PALETTE_SEARCH_MASK (FI_COLOR_FIND_EQUAL_COLOR | FI_COLOR_ALPHA_IS_INDEX) // No color lookup is performed + +// RescaleEx options --------------------------------------------------------- +// Constants used in FreeImage_RescaleEx + +#define FI_RESCALE_DEFAULT 0x00 //! default options; none of the following other options apply +#define FI_RESCALE_TRUE_COLOR 0x01 //! for non-transparent greyscale images, convert to 24-bit if src bitdepth <= 8 (default is a 8-bit greyscale image). +#define FI_RESCALE_OMIT_METADATA 0x02 //! do not copy metadata to the rescaled image + + +#ifdef __cplusplus +extern "C" { +#endif + +// Init / Error routines ---------------------------------------------------- + +DLL_API void DLL_CALLCONV FreeImage_Initialise(BOOL load_local_plugins_only FI_DEFAULT(FALSE)); +DLL_API void DLL_CALLCONV FreeImage_DeInitialise(void); + +// Version routines --------------------------------------------------------- + +DLL_API const char *DLL_CALLCONV FreeImage_GetVersion(void); +DLL_API const char *DLL_CALLCONV FreeImage_GetCopyrightMessage(void); + +// Message output functions ------------------------------------------------- + +typedef void (*FreeImage_OutputMessageFunction)(FREE_IMAGE_FORMAT fif, const char *msg); +typedef void (DLL_CALLCONV *FreeImage_OutputMessageFunctionStdCall)(FREE_IMAGE_FORMAT fif, const char *msg); + +DLL_API void DLL_CALLCONV FreeImage_SetOutputMessageStdCall(FreeImage_OutputMessageFunctionStdCall omf); +DLL_API void DLL_CALLCONV FreeImage_SetOutputMessage(FreeImage_OutputMessageFunction omf); +DLL_API void DLL_CALLCONV FreeImage_OutputMessageProc(int fif, const char *fmt, ...); + +// Allocate / Clone / Unload routines --------------------------------------- + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Allocate(int width, int height, int bpp, unsigned red_mask FI_DEFAULT(0), unsigned green_mask FI_DEFAULT(0), unsigned blue_mask FI_DEFAULT(0)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_AllocateT(FREE_IMAGE_TYPE type, int width, int height, int bpp FI_DEFAULT(8), unsigned red_mask FI_DEFAULT(0), unsigned green_mask FI_DEFAULT(0), unsigned blue_mask FI_DEFAULT(0)); +DLL_API FIBITMAP * DLL_CALLCONV FreeImage_Clone(FIBITMAP *dib); +DLL_API void DLL_CALLCONV FreeImage_Unload(FIBITMAP *dib); + +// Header loading routines +DLL_API BOOL DLL_CALLCONV FreeImage_HasPixels(FIBITMAP *dib); + +// Load / Save routines ----------------------------------------------------- + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Load(FREE_IMAGE_FORMAT fif, const char *filename, int flags FI_DEFAULT(0)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_LoadU(FREE_IMAGE_FORMAT fif, const wchar_t *filename, int flags FI_DEFAULT(0)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_LoadFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0)); +DLL_API BOOL DLL_CALLCONV FreeImage_Save(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, const char *filename, int flags FI_DEFAULT(0)); +DLL_API BOOL DLL_CALLCONV FreeImage_SaveU(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, const wchar_t *filename, int flags FI_DEFAULT(0)); +DLL_API BOOL DLL_CALLCONV FreeImage_SaveToHandle(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0)); + +// Memory I/O stream routines ----------------------------------------------- + +DLL_API FIMEMORY *DLL_CALLCONV FreeImage_OpenMemory(BYTE *data FI_DEFAULT(0), DWORD size_in_bytes FI_DEFAULT(0)); +DLL_API void DLL_CALLCONV FreeImage_CloseMemory(FIMEMORY *stream); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_LoadFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int flags FI_DEFAULT(0)); +DLL_API BOOL DLL_CALLCONV FreeImage_SaveToMemory(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, FIMEMORY *stream, int flags FI_DEFAULT(0)); +DLL_API long DLL_CALLCONV FreeImage_TellMemory(FIMEMORY *stream); +DLL_API BOOL DLL_CALLCONV FreeImage_SeekMemory(FIMEMORY *stream, long offset, int origin); +DLL_API BOOL DLL_CALLCONV FreeImage_AcquireMemory(FIMEMORY *stream, BYTE **data, DWORD *size_in_bytes); +DLL_API unsigned DLL_CALLCONV FreeImage_ReadMemory(void *buffer, unsigned size, unsigned count, FIMEMORY *stream); +DLL_API unsigned DLL_CALLCONV FreeImage_WriteMemory(const void *buffer, unsigned size, unsigned count, FIMEMORY *stream); + +DLL_API FIMULTIBITMAP *DLL_CALLCONV FreeImage_LoadMultiBitmapFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int flags FI_DEFAULT(0)); +DLL_API BOOL DLL_CALLCONV FreeImage_SaveMultiBitmapToMemory(FREE_IMAGE_FORMAT fif, FIMULTIBITMAP *bitmap, FIMEMORY *stream, int flags); + +// Plugin Interface --------------------------------------------------------- + +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_RegisterLocalPlugin(FI_InitProc proc_address, const char *format FI_DEFAULT(0), const char *description FI_DEFAULT(0), const char *extension FI_DEFAULT(0), const char *regexpr FI_DEFAULT(0)); +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_RegisterExternalPlugin(const char *path, const char *format FI_DEFAULT(0), const char *description FI_DEFAULT(0), const char *extension FI_DEFAULT(0), const char *regexpr FI_DEFAULT(0)); +DLL_API int DLL_CALLCONV FreeImage_GetFIFCount(void); +DLL_API int DLL_CALLCONV FreeImage_SetPluginEnabled(FREE_IMAGE_FORMAT fif, BOOL enable); +DLL_API int DLL_CALLCONV FreeImage_IsPluginEnabled(FREE_IMAGE_FORMAT fif); +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFIFFromFormat(const char *format); +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFIFFromMime(const char *mime); +DLL_API const char *DLL_CALLCONV FreeImage_GetFormatFromFIF(FREE_IMAGE_FORMAT fif); +DLL_API const char *DLL_CALLCONV FreeImage_GetFIFExtensionList(FREE_IMAGE_FORMAT fif); +DLL_API const char *DLL_CALLCONV FreeImage_GetFIFDescription(FREE_IMAGE_FORMAT fif); +DLL_API const char *DLL_CALLCONV FreeImage_GetFIFRegExpr(FREE_IMAGE_FORMAT fif); +DLL_API const char *DLL_CALLCONV FreeImage_GetFIFMimeType(FREE_IMAGE_FORMAT fif); +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFIFFromFilename(const char *filename); +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFIFFromFilenameU(const wchar_t *filename); +DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsReading(FREE_IMAGE_FORMAT fif); +DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsWriting(FREE_IMAGE_FORMAT fif); +DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsExportBPP(FREE_IMAGE_FORMAT fif, int bpp); +DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsExportType(FREE_IMAGE_FORMAT fif, FREE_IMAGE_TYPE type); +DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsICCProfiles(FREE_IMAGE_FORMAT fif); +DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsNoPixels(FREE_IMAGE_FORMAT fif); + +// Multipaging interface ---------------------------------------------------- + +DLL_API FIMULTIBITMAP * DLL_CALLCONV FreeImage_OpenMultiBitmap(FREE_IMAGE_FORMAT fif, const char *filename, BOOL create_new, BOOL read_only, BOOL keep_cache_in_memory FI_DEFAULT(FALSE), int flags FI_DEFAULT(0)); +DLL_API FIMULTIBITMAP * DLL_CALLCONV FreeImage_OpenMultiBitmapFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0)); +DLL_API BOOL DLL_CALLCONV FreeImage_SaveMultiBitmapToHandle(FREE_IMAGE_FORMAT fif, FIMULTIBITMAP *bitmap, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0)); +DLL_API BOOL DLL_CALLCONV FreeImage_CloseMultiBitmap(FIMULTIBITMAP *bitmap, int flags FI_DEFAULT(0)); +DLL_API int DLL_CALLCONV FreeImage_GetPageCount(FIMULTIBITMAP *bitmap); +DLL_API void DLL_CALLCONV FreeImage_AppendPage(FIMULTIBITMAP *bitmap, FIBITMAP *data); +DLL_API void DLL_CALLCONV FreeImage_InsertPage(FIMULTIBITMAP *bitmap, int page, FIBITMAP *data); +DLL_API void DLL_CALLCONV FreeImage_DeletePage(FIMULTIBITMAP *bitmap, int page); +DLL_API FIBITMAP * DLL_CALLCONV FreeImage_LockPage(FIMULTIBITMAP *bitmap, int page); +DLL_API void DLL_CALLCONV FreeImage_UnlockPage(FIMULTIBITMAP *bitmap, FIBITMAP *data, BOOL changed); +DLL_API BOOL DLL_CALLCONV FreeImage_MovePage(FIMULTIBITMAP *bitmap, int target, int source); +DLL_API BOOL DLL_CALLCONV FreeImage_GetLockedPageNumbers(FIMULTIBITMAP *bitmap, int *pages, int *count); + +// File type request routines ------------------------------------------------ + +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileType(const char *filename, int size FI_DEFAULT(0)); +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeU(const wchar_t *filename, int size FI_DEFAULT(0)); +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size FI_DEFAULT(0)); +DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromMemory(FIMEMORY *stream, int size FI_DEFAULT(0)); + +DLL_API BOOL DLL_CALLCONV FreeImage_Validate(FREE_IMAGE_FORMAT fif, const char *filename); +DLL_API BOOL DLL_CALLCONV FreeImage_ValidateU(FREE_IMAGE_FORMAT fif, const wchar_t *filename); +DLL_API BOOL DLL_CALLCONV FreeImage_ValidateFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle); +DLL_API BOOL DLL_CALLCONV FreeImage_ValidateFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream); + + +// Image type request routine ----------------------------------------------- + +DLL_API FREE_IMAGE_TYPE DLL_CALLCONV FreeImage_GetImageType(FIBITMAP *dib); + +// FreeImage helper routines ------------------------------------------------ + +DLL_API BOOL DLL_CALLCONV FreeImage_IsLittleEndian(void); +DLL_API BOOL DLL_CALLCONV FreeImage_LookupX11Color(const char *szColor, BYTE *nRed, BYTE *nGreen, BYTE *nBlue); +DLL_API BOOL DLL_CALLCONV FreeImage_LookupSVGColor(const char *szColor, BYTE *nRed, BYTE *nGreen, BYTE *nBlue); + +// Pixel access routines ---------------------------------------------------- + +DLL_API BYTE *DLL_CALLCONV FreeImage_GetBits(FIBITMAP *dib); +DLL_API BYTE *DLL_CALLCONV FreeImage_GetScanLine(FIBITMAP *dib, int scanline); + +DLL_API BOOL DLL_CALLCONV FreeImage_GetPixelIndex(FIBITMAP *dib, unsigned x, unsigned y, BYTE *value); +DLL_API BOOL DLL_CALLCONV FreeImage_GetPixelColor(FIBITMAP *dib, unsigned x, unsigned y, RGBQUAD *value); +DLL_API BOOL DLL_CALLCONV FreeImage_SetPixelIndex(FIBITMAP *dib, unsigned x, unsigned y, BYTE *value); +DLL_API BOOL DLL_CALLCONV FreeImage_SetPixelColor(FIBITMAP *dib, unsigned x, unsigned y, RGBQUAD *value); + +// DIB info routines -------------------------------------------------------- + +DLL_API unsigned DLL_CALLCONV FreeImage_GetColorsUsed(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetBPP(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetWidth(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetHeight(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetLine(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetPitch(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetDIBSize(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetMemorySize(FIBITMAP *dib); +DLL_API RGBQUAD *DLL_CALLCONV FreeImage_GetPalette(FIBITMAP *dib); + +DLL_API unsigned DLL_CALLCONV FreeImage_GetDotsPerMeterX(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetDotsPerMeterY(FIBITMAP *dib); +DLL_API void DLL_CALLCONV FreeImage_SetDotsPerMeterX(FIBITMAP *dib, unsigned res); +DLL_API void DLL_CALLCONV FreeImage_SetDotsPerMeterY(FIBITMAP *dib, unsigned res); + +DLL_API BITMAPINFOHEADER *DLL_CALLCONV FreeImage_GetInfoHeader(FIBITMAP *dib); +DLL_API BITMAPINFO *DLL_CALLCONV FreeImage_GetInfo(FIBITMAP *dib); +DLL_API FREE_IMAGE_COLOR_TYPE DLL_CALLCONV FreeImage_GetColorType(FIBITMAP *dib); + +DLL_API unsigned DLL_CALLCONV FreeImage_GetRedMask(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetGreenMask(FIBITMAP *dib); +DLL_API unsigned DLL_CALLCONV FreeImage_GetBlueMask(FIBITMAP *dib); + +DLL_API unsigned DLL_CALLCONV FreeImage_GetTransparencyCount(FIBITMAP *dib); +DLL_API BYTE * DLL_CALLCONV FreeImage_GetTransparencyTable(FIBITMAP *dib); +DLL_API void DLL_CALLCONV FreeImage_SetTransparent(FIBITMAP *dib, BOOL enabled); +DLL_API void DLL_CALLCONV FreeImage_SetTransparencyTable(FIBITMAP *dib, BYTE *table, int count); +DLL_API BOOL DLL_CALLCONV FreeImage_IsTransparent(FIBITMAP *dib); +DLL_API void DLL_CALLCONV FreeImage_SetTransparentIndex(FIBITMAP *dib, int index); +DLL_API int DLL_CALLCONV FreeImage_GetTransparentIndex(FIBITMAP *dib); + +DLL_API BOOL DLL_CALLCONV FreeImage_HasBackgroundColor(FIBITMAP *dib); +DLL_API BOOL DLL_CALLCONV FreeImage_GetBackgroundColor(FIBITMAP *dib, RGBQUAD *bkcolor); +DLL_API BOOL DLL_CALLCONV FreeImage_SetBackgroundColor(FIBITMAP *dib, RGBQUAD *bkcolor); + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_GetThumbnail(FIBITMAP *dib); +DLL_API BOOL DLL_CALLCONV FreeImage_SetThumbnail(FIBITMAP *dib, FIBITMAP *thumbnail); + +// ICC profile routines ----------------------------------------------------- + +DLL_API FIICCPROFILE *DLL_CALLCONV FreeImage_GetICCProfile(FIBITMAP *dib); +DLL_API FIICCPROFILE *DLL_CALLCONV FreeImage_CreateICCProfile(FIBITMAP *dib, void *data, long size); +DLL_API void DLL_CALLCONV FreeImage_DestroyICCProfile(FIBITMAP *dib); + +// Line conversion routines ------------------------------------------------- + +DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To4(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To4(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To4_555(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To4_565(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To4(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To4(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To8(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To8(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To8_555(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To8_565(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To8(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To8(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To16_555(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To16_555(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To16_555(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16_565_To16_555(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To16_555(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To16_555(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To16_565(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To16_565(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To16_565(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16_555_To16_565(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To16_565(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To16_565(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To24(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To24(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To24(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To24_555(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To24_565(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To24(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To32_555(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To32_565(BYTE *target, BYTE *source, int width_in_pixels); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To32(BYTE *target, BYTE *source, int width_in_pixels); + +// Smart conversion routines ------------------------------------------------ + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo4Bits(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo8Bits(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToGreyscale(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo16Bits555(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo16Bits565(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo24Bits(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo32Bits(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ColorQuantize(FIBITMAP *dib, FREE_IMAGE_QUANTIZE quantize); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ColorQuantizeEx(FIBITMAP *dib, FREE_IMAGE_QUANTIZE quantize FI_DEFAULT(FIQ_WUQUANT), int PaletteSize FI_DEFAULT(256), int ReserveSize FI_DEFAULT(0), RGBQUAD *ReservePalette FI_DEFAULT(NULL)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Threshold(FIBITMAP *dib, BYTE T); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Dither(FIBITMAP *dib, FREE_IMAGE_DITHER algorithm); + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertFromRawBits(BYTE *bits, int width, int height, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown FI_DEFAULT(FALSE)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertFromRawBitsEx(BOOL copySource, BYTE *bits, FREE_IMAGE_TYPE type, int width, int height, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown FI_DEFAULT(FALSE)); +DLL_API void DLL_CALLCONV FreeImage_ConvertToRawBits(BYTE *bits, FIBITMAP *dib, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown FI_DEFAULT(FALSE)); + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToFloat(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToRGBF(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToRGBAF(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToUINT16(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToRGB16(FIBITMAP *dib); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToRGBA16(FIBITMAP *dib); + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToStandardType(FIBITMAP *src, BOOL scale_linear FI_DEFAULT(TRUE)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToType(FIBITMAP *src, FREE_IMAGE_TYPE dst_type, BOOL scale_linear FI_DEFAULT(TRUE)); + +// Tone mapping operators --------------------------------------------------- + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ToneMapping(FIBITMAP *dib, FREE_IMAGE_TMO tmo, double first_param FI_DEFAULT(0), double second_param FI_DEFAULT(0)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_TmoDrago03(FIBITMAP *src, double gamma FI_DEFAULT(2.2), double exposure FI_DEFAULT(0)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_TmoReinhard05(FIBITMAP *src, double intensity FI_DEFAULT(0), double contrast FI_DEFAULT(0)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_TmoReinhard05Ex(FIBITMAP *src, double intensity FI_DEFAULT(0), double contrast FI_DEFAULT(0), double adaptation FI_DEFAULT(1), double color_correction FI_DEFAULT(0)); + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_TmoFattal02(FIBITMAP *src, double color_saturation FI_DEFAULT(0.5), double attenuation FI_DEFAULT(0.85)); + +// ZLib interface ----------------------------------------------------------- + +DLL_API DWORD DLL_CALLCONV FreeImage_ZLibCompress(BYTE *target, DWORD target_size, BYTE *source, DWORD source_size); +DLL_API DWORD DLL_CALLCONV FreeImage_ZLibUncompress(BYTE *target, DWORD target_size, BYTE *source, DWORD source_size); +DLL_API DWORD DLL_CALLCONV FreeImage_ZLibGZip(BYTE *target, DWORD target_size, BYTE *source, DWORD source_size); +DLL_API DWORD DLL_CALLCONV FreeImage_ZLibGUnzip(BYTE *target, DWORD target_size, BYTE *source, DWORD source_size); +DLL_API DWORD DLL_CALLCONV FreeImage_ZLibCRC32(DWORD crc, BYTE *source, DWORD source_size); + +// -------------------------------------------------------------------------- +// Metadata routines +// -------------------------------------------------------------------------- + +// tag creation / destruction +DLL_API FITAG *DLL_CALLCONV FreeImage_CreateTag(void); +DLL_API void DLL_CALLCONV FreeImage_DeleteTag(FITAG *tag); +DLL_API FITAG *DLL_CALLCONV FreeImage_CloneTag(FITAG *tag); + +// tag getters and setters +DLL_API const char *DLL_CALLCONV FreeImage_GetTagKey(FITAG *tag); +DLL_API const char *DLL_CALLCONV FreeImage_GetTagDescription(FITAG *tag); +DLL_API WORD DLL_CALLCONV FreeImage_GetTagID(FITAG *tag); +DLL_API FREE_IMAGE_MDTYPE DLL_CALLCONV FreeImage_GetTagType(FITAG *tag); +DLL_API DWORD DLL_CALLCONV FreeImage_GetTagCount(FITAG *tag); +DLL_API DWORD DLL_CALLCONV FreeImage_GetTagLength(FITAG *tag); +DLL_API const void *DLL_CALLCONV FreeImage_GetTagValue(FITAG *tag); + +DLL_API BOOL DLL_CALLCONV FreeImage_SetTagKey(FITAG *tag, const char *key); +DLL_API BOOL DLL_CALLCONV FreeImage_SetTagDescription(FITAG *tag, const char *description); +DLL_API BOOL DLL_CALLCONV FreeImage_SetTagID(FITAG *tag, WORD id); +DLL_API BOOL DLL_CALLCONV FreeImage_SetTagType(FITAG *tag, FREE_IMAGE_MDTYPE type); +DLL_API BOOL DLL_CALLCONV FreeImage_SetTagCount(FITAG *tag, DWORD count); +DLL_API BOOL DLL_CALLCONV FreeImage_SetTagLength(FITAG *tag, DWORD length); +DLL_API BOOL DLL_CALLCONV FreeImage_SetTagValue(FITAG *tag, const void *value); + +// iterator +DLL_API FIMETADATA *DLL_CALLCONV FreeImage_FindFirstMetadata(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, FITAG **tag); +DLL_API BOOL DLL_CALLCONV FreeImage_FindNextMetadata(FIMETADATA *mdhandle, FITAG **tag); +DLL_API void DLL_CALLCONV FreeImage_FindCloseMetadata(FIMETADATA *mdhandle); + +// metadata setter and getter +DLL_API BOOL DLL_CALLCONV FreeImage_SetMetadata(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, const char *key, FITAG *tag); +DLL_API BOOL DLL_CALLCONV FreeImage_GetMetadata(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, const char *key, FITAG **tag); +DLL_API BOOL DLL_CALLCONV FreeImage_SetMetadataKeyValue(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, const char *key, const char *value); + +// helpers +DLL_API unsigned DLL_CALLCONV FreeImage_GetMetadataCount(FREE_IMAGE_MDMODEL model, FIBITMAP *dib); +DLL_API BOOL DLL_CALLCONV FreeImage_CloneMetadata(FIBITMAP *dst, FIBITMAP *src); + +// tag to C string conversion +DLL_API const char* DLL_CALLCONV FreeImage_TagToString(FREE_IMAGE_MDMODEL model, FITAG *tag, char *Make FI_DEFAULT(NULL)); + +// -------------------------------------------------------------------------- +// JPEG lossless transformation routines +// -------------------------------------------------------------------------- + +DLL_API BOOL DLL_CALLCONV FreeImage_JPEGTransform(const char *src_file, const char *dst_file, FREE_IMAGE_JPEG_OPERATION operation, BOOL perfect FI_DEFAULT(TRUE)); +DLL_API BOOL DLL_CALLCONV FreeImage_JPEGTransformU(const wchar_t *src_file, const wchar_t *dst_file, FREE_IMAGE_JPEG_OPERATION operation, BOOL perfect FI_DEFAULT(TRUE)); +DLL_API BOOL DLL_CALLCONV FreeImage_JPEGCrop(const char *src_file, const char *dst_file, int left, int top, int right, int bottom); +DLL_API BOOL DLL_CALLCONV FreeImage_JPEGCropU(const wchar_t *src_file, const wchar_t *dst_file, int left, int top, int right, int bottom); +DLL_API BOOL DLL_CALLCONV FreeImage_JPEGTransformFromHandle(FreeImageIO* src_io, fi_handle src_handle, FreeImageIO* dst_io, fi_handle dst_handle, FREE_IMAGE_JPEG_OPERATION operation, int* left, int* top, int* right, int* bottom, BOOL perfect FI_DEFAULT(TRUE)); +DLL_API BOOL DLL_CALLCONV FreeImage_JPEGTransformCombined(const char *src_file, const char *dst_file, FREE_IMAGE_JPEG_OPERATION operation, int* left, int* top, int* right, int* bottom, BOOL perfect FI_DEFAULT(TRUE)); +DLL_API BOOL DLL_CALLCONV FreeImage_JPEGTransformCombinedU(const wchar_t *src_file, const wchar_t *dst_file, FREE_IMAGE_JPEG_OPERATION operation, int* left, int* top, int* right, int* bottom, BOOL perfect FI_DEFAULT(TRUE)); +DLL_API BOOL DLL_CALLCONV FreeImage_JPEGTransformCombinedFromMemory(FIMEMORY* src_stream, FIMEMORY* dst_stream, FREE_IMAGE_JPEG_OPERATION operation, int* left, int* top, int* right, int* bottom, BOOL perfect FI_DEFAULT(TRUE)); + + +// -------------------------------------------------------------------------- +// Image manipulation toolkit +// -------------------------------------------------------------------------- + +// rotation and flipping +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Rotate(FIBITMAP *dib, double angle, const void *bkcolor FI_DEFAULT(NULL)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_RotateEx(FIBITMAP *dib, double angle, double x_shift, double y_shift, double x_origin, double y_origin, BOOL use_mask); +DLL_API BOOL DLL_CALLCONV FreeImage_FlipHorizontal(FIBITMAP *dib); +DLL_API BOOL DLL_CALLCONV FreeImage_FlipVertical(FIBITMAP *dib); + +// upsampling / downsampling +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Rescale(FIBITMAP *dib, int dst_width, int dst_height, FREE_IMAGE_FILTER filter FI_DEFAULT(FILTER_CATMULLROM)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_MakeThumbnail(FIBITMAP *dib, int max_pixel_size, BOOL convert FI_DEFAULT(TRUE)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_RescaleRect(FIBITMAP *dib, int dst_width, int dst_height, int left, int top, int right, int bottom, FREE_IMAGE_FILTER filter FI_DEFAULT(FILTER_CATMULLROM), unsigned flags FI_DEFAULT(0)); + +// color manipulation routines (point operations) +DLL_API BOOL DLL_CALLCONV FreeImage_AdjustCurve(FIBITMAP *dib, BYTE *LUT, FREE_IMAGE_COLOR_CHANNEL channel); +DLL_API BOOL DLL_CALLCONV FreeImage_AdjustGamma(FIBITMAP *dib, double gamma); +DLL_API BOOL DLL_CALLCONV FreeImage_AdjustBrightness(FIBITMAP *dib, double percentage); +DLL_API BOOL DLL_CALLCONV FreeImage_AdjustContrast(FIBITMAP *dib, double percentage); +DLL_API BOOL DLL_CALLCONV FreeImage_Invert(FIBITMAP *dib); +DLL_API BOOL DLL_CALLCONV FreeImage_GetHistogram(FIBITMAP *dib, DWORD *histo, FREE_IMAGE_COLOR_CHANNEL channel FI_DEFAULT(FICC_BLACK)); +DLL_API int DLL_CALLCONV FreeImage_GetAdjustColorsLookupTable(BYTE *LUT, double brightness, double contrast, double gamma, BOOL invert); +DLL_API BOOL DLL_CALLCONV FreeImage_AdjustColors(FIBITMAP *dib, double brightness, double contrast, double gamma, BOOL invert FI_DEFAULT(FALSE)); +DLL_API unsigned DLL_CALLCONV FreeImage_ApplyColorMapping(FIBITMAP *dib, RGBQUAD *srccolors, RGBQUAD *dstcolors, unsigned count, BOOL ignore_alpha, BOOL swap); +DLL_API unsigned DLL_CALLCONV FreeImage_SwapColors(FIBITMAP *dib, RGBQUAD *color_a, RGBQUAD *color_b, BOOL ignore_alpha); +DLL_API unsigned DLL_CALLCONV FreeImage_ApplyPaletteIndexMapping(FIBITMAP *dib, BYTE *srcindices, BYTE *dstindices, unsigned count, BOOL swap); +DLL_API unsigned DLL_CALLCONV FreeImage_SwapPaletteIndices(FIBITMAP *dib, BYTE *index_a, BYTE *index_b); + +// channel processing routines +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_GetChannel(FIBITMAP *dib, FREE_IMAGE_COLOR_CHANNEL channel); +DLL_API BOOL DLL_CALLCONV FreeImage_SetChannel(FIBITMAP *dst, FIBITMAP *src, FREE_IMAGE_COLOR_CHANNEL channel); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_GetComplexChannel(FIBITMAP *src, FREE_IMAGE_COLOR_CHANNEL channel); +DLL_API BOOL DLL_CALLCONV FreeImage_SetComplexChannel(FIBITMAP *dst, FIBITMAP *src, FREE_IMAGE_COLOR_CHANNEL channel); + +// copy / paste / composite routines +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Copy(FIBITMAP *dib, int left, int top, int right, int bottom); +DLL_API BOOL DLL_CALLCONV FreeImage_Paste(FIBITMAP *dst, FIBITMAP *src, int left, int top, int alpha); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_CreateView(FIBITMAP *dib, unsigned left, unsigned top, unsigned right, unsigned bottom); + +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Composite(FIBITMAP *fg, BOOL useFileBkg FI_DEFAULT(FALSE), RGBQUAD *appBkColor FI_DEFAULT(NULL), FIBITMAP *bg FI_DEFAULT(NULL)); +DLL_API BOOL DLL_CALLCONV FreeImage_PreMultiplyWithAlpha(FIBITMAP *dib); + +// background filling routines +DLL_API BOOL DLL_CALLCONV FreeImage_FillBackground(FIBITMAP *dib, const void *color, int options FI_DEFAULT(0)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_EnlargeCanvas(FIBITMAP *src, int left, int top, int right, int bottom, const void *color, int options FI_DEFAULT(0)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_AllocateEx(int width, int height, int bpp, const RGBQUAD *color, int options FI_DEFAULT(0), const RGBQUAD *palette FI_DEFAULT(NULL), unsigned red_mask FI_DEFAULT(0), unsigned green_mask FI_DEFAULT(0), unsigned blue_mask FI_DEFAULT(0)); +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_AllocateExT(FREE_IMAGE_TYPE type, int width, int height, int bpp, const void *color, int options FI_DEFAULT(0), const RGBQUAD *palette FI_DEFAULT(NULL), unsigned red_mask FI_DEFAULT(0), unsigned green_mask FI_DEFAULT(0), unsigned blue_mask FI_DEFAULT(0)); + +// miscellaneous algorithms +DLL_API FIBITMAP *DLL_CALLCONV FreeImage_MultigridPoissonSolver(FIBITMAP *Laplacian, int ncycle FI_DEFAULT(3)); + +// restore the borland-specific enum size option +#if defined(__BORLANDC__) +#pragma option pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif // FREEIMAGE_H diff --git a/deps/freeimage/lib/libfreeimage.a b/deps/freeimage/lib/libfreeimage.a new file mode 100644 index 0000000000000000000000000000000000000000..79fe5c8cb6e344b3c2ddbe456fe5df265c7e1551 GIT binary patch literal 20182232 zcmYJ+1yq$=x5n{B7@#7EN*Rc#Aflimh#ep{iV7B@7}yD7fDITZc3>x>B6cfwD=H=i zCU$q;wZHj4rHqY~%BMBa|LdWWgU=ZLv#u4? zDxJTpMN4z^e=;dkyZf;4h`Q!wJ*!mpaQy%O@vKp`dQ~4!Pfs65M=uXgy&%h;9v(HS zS9f%*=I!Ii_I`I*)3m4>stXN8F}wWyo`I z7`8=U{6~Lie(6s$7R#H7NzAvT|1|6O@h6U>FPZF2|3vZ*&gn;=i>b`_$HDXkV_kGb zD{RgF9_)+7`B;MY@Q=PnSQ&THcL85xUhY>8b^HI`Uj*~M;BAbg?>KoQ{Y5dA`W*DZ zF<6*$+cRfeUO6vPf1?ba+jrjIV?2p==1N(5;TWrpHHT^AqzALY?!HzgmuN&%{u?cm}Rc1SXe&Q z8xydG{-PP`w#CH_)SniU+>Z5=)Q6L2;YK`;Ep27rU2;hq$@%dU=iJ9E&e=#Fj|Zu5 z#*Wmz@H_K=>*q7vKasv2oYM!Z;$!ar6U(6y^K6)B#hkX-5G!B|HfQbtav|n*(a#_7 zH=i1+9a1m9O4jDI$*k?H^{nox;Ur<@OimuvQdkU(siu(7pn*~)uC2!b?~W?J(C(`uAfJ z_QASX6z6kJkUrONUL5Yl=d9G-a$X!^Uz;kTF3%G%K-+bgeTWpGB(2==I$oudX<}z;< z^G4!tZ<(8eColy^VRN)cW8POH=dQy;cpVkzxbU2AP=4Ucm#n7Lza)LQCkSd_YPpwur?e~l&a zGkq5^1>3SdTkluyMN|-ap)DS7BkM+O#dPvAoQ5q~A4%?n_0S0m;11>wMW6QiJ+>;M z#srD8(H+CF5vH}1zH993Ngj>A^nDETtmyxN_whA-rLX~>V|_O^?4Z9F$wibxTYRO@ zHPkDUCxz(WKQcM><_Ogx3duoK?HKg{dGyf48rrxA54@K-ouZ$p83;o7;fVH zrQPM+$~{E0uHstmYtDKG>!WZ(sPqM6KD1zdWo(UYnDdUl$K<`7*ABh8*ACuW4*R>2 z$M({HPZ)2l9_VcFJZ|bK`7=2`eU4ZI+tAmN{E6HfAD|f?!+Ge4bubp!=y@rNtkrHj zr;RvhtsY{{KKjq+=0(*y?1<^TrEW)_OzsyU^%mrN*p$A~(0c4D zt_I*LZQ#-3>HroSq<_E4Dy}}_BwUZzbe~~8gPcpgO|F5zsdp!v57vJ!`&L|q57+;k z(A7o_*4f}xT#k>?Xo#%aV>N7p{m^ch^cmx;p^~rT5!{ILa0lm1B%ddrWzKd?#wj=$ zJ7Qz3ij%n4YCMQH@Cz2^+)AA5N^XWB)cvqG^+%lZ8O?Z~rO^vpVEz&M_wPU(wGyji z0*2yP-EZhSihFf^(QO;`PHX$XM&*qZPm)WJtD+xv!aMX0B#+lxzP3^GF%>hkLq6K5 z>)JELY}H$BKt)@XCrbbMsJ5-L)!yoAs~Ty~oV8VzFjO0H-Byj%I%eCd8Csu$cIvct zQAIoT0M}wVnvB$cUaw-Os$u}X(d&kKGI=U?#UWS%cWNy|?bJm>9%QHfX``pvsT}MS zt?#kSPEE%u=#TqwEe=Op%s)y$f2y52ud~4i_z6q1UR4{m(@u5J23)aIO|XwPI@?Y~ z;uNiVYNwWK$D7)#J%+l2y*j6@?`^NXYSZKF)qS)ct^fJe3VSs`>#^NlHNcKo2@h%O z|FBo_xDqq9DTN%=bFGKHgEAVUe?4__P(`$X9uBIaHo?n5`C?l`y`zH)*FFz(P)En= zd-iuwIrtv`p+$_WmqK@}gXZ+LAa}+edcI-q3%rG=aSyJ?`8Wkfpab*W&=;Fx2=>7! zoPzUk4Q|IPI6&VwA%6)Kqs_D|p?=2d&&#%idWG3|0S{psuD~RmfWt5x+o2zNp)*>e z34YY~G2G)JUcn69iYss?x{Q;3<`{{+F&LYm587dzcJHYY>YUc{MG3VZH{v2JI9}HO zkniAIET`Ag-<43cwFy=w)e>z=_4f^XpsK!Uo1LNas{l5opBJx;#^F@6L=T@VM)&Q#x59% z({L@GjFWq)DWW9~rJjk-)WgVuSRXyH6c)z6?0bu~unqRX@i+(9;0`>2SMVO%^M0#g z3k=5II1U$LDz4(5^Kb$lWjza@<383c67=sALrST-@uE8xLlgX{`we}M@i+CC7>;*v z5RSt+*o*U8;eP53$Q#M-WCxst7g-NP{~7w{Wl1TOmMG4}(HMpe&;<+P2ln5>!?*(D za3pra%2*upS!Ui8u}iVh5~? zu4s*U@Y_^5=P_Q#3|x;>a3}_2U95z*sPL`+d<~yt4qn6~xDD6fIsN&CT`Z+;;9LBT zHD}6tC{{oRoQTbEFq-2gZA5k{bqurcHO|5ONz(UmmUtUa;Wk``@i+p*uqAq*rPWH@gPZ5*zwd1> zts2f1JCSedbwm9Kxd-dE_<;IbG@-s5*WyU5PoD?*JkG(-oM%nnAgqK5xD;Q{(|^9H z=BS((h?e9>dY+;F6D?UU!@397$KI?j!+-N-|0}$MXK^oXzy&x3M_@R%#RlksrO^Wa zaGz{Ehk@Ly7Ve`yhMYoPh;bN+y>Kf1t;i)7>OX(qbX1!biTm&(-osb;1M4l8{?+U+ zMBM?4u|AdcUetrJDVC+r6SwO78Se7}voV4>-^d5am6&sn+zxAF9{h)`IcG4&<15xH z;&A59!ew}j^NS_xe~whDjLKLdrs7OA!{2(oq3;={pey@h>03(uIyR&pil?Z5C+A~- zdGa&7jze*#?(?Z#Mh(S|=#OJ@$TI!wQKK@-Z@JhWhvImgh0FCmL;rrfhOcoa^JZfU ztc0JiB>rA1^B&?I>Q~6sIkzmPQ=fxTSd{f(a&63qWpIV=%Uo1O#jezUUtCv4tym#O z<6pgQsAsYM1V3YCd`@3O_LZV;ftjp-XZ;9u(^WFRE%kKjEAbKay5v?Eii2<}eM#i= zSujj$+Q)MgHLQW^M8YZ>LFZlTF){rk^E zC*_K^*c`plevRI@#7R}g2G~!p8|o)9FZCbfTJ?6{-6T z9>y$O$NEe1A3RR|2EM|7SY(~dD~~&=dt*}!#sOFg3*dNM$GJ%uqUWZRDywSXPqbez zbq}nE9dRJWpdb5Yk^7Lx;9Bal$jdMtkKs*xhL7~VurX!TW&DA=vA_oX_xiTZ${E|C zFGk=P?fY}iYP~k+nzOow2XGN4Vucj__w#ILRRsU(x*@;7+SC)Y0gs*47EH$0*aI^# z62EH$Czn&#@EI20sQbJfCn%Y7vl_!#@^ToTVO48MLRUXPx?6w_kWCY^?j1AxvF*AfM>4i zqIOZ^ifRw$*`ojX(d3FMM`wed@q(_a{T0~JC<-$KeT%*xTy@>iqCN+HrpnBHL)OGXWgD$5yQ0aecaR#ZBlJF zbr|Du6{capcK!Wm?50BThOQg(Pke?8Sf7MLu>h7qPh6*c-q%fCFc{~iw&MYOfG@RY zlHAm1{D)pUbbXsSs?1`|v29$7?tnV{s%7!etnb>#zrw*rh)&-%6?=n&2|lU@L5lzUYbNajACvph{{S&cHNn(!5IQ)NcLj`npPLAdbVE zdfia>B0nLY#QD@4;%a=)x-Gc^?!-{ci-CBMeK&RX_*zN5#Cm)5@24j2>W9t-^N_8v z6jsKj*cpduSJrh`y>X{Dy0N=jjqx}em*6-ozgK^cn!BqjIveyM`{N_(AJCY3Q9Me0 z$Ugn=Wwdiw_4kVlFcin)ngg=FM(;QDJ5m3|{-<~uchh$l_fubt->6%XU9ll{!FY_I zzYh0kgS~Jxo~5rnT5-=Yrx}$HWi%K88G$dV9=8OT3EpF#`uPXCf{^Q`XbSA=m(~ajpk_ zj%d$%3V9CRqyMj7PqFY&$M7cRqV;iEFN?m|8hhhJoQpTL(G@(Ds6iNtvoIESXp>HRD0No6K+eYZ=xkW`@KnXH7B)w>bNc77 zlc(~-5VXS4y3ep4PkusPLry18!xcD`^&Vss@=5Yroh?s$s*89C9nMR=ApWI(58ZWL z-SJfYuo*5y-wXQRpULr5r*t-$Ox}T`Z|lD&ef3m6mqcrPdr|UPoQ>w$QV$`!qY1vc zBkL9Eb0Np#@9VN&`i6K--@|bJK757Q^zFyR*aBB($-Yw9<(lNe7=Bgq!z*HG{E;d7 z8g9XOY>4?V`?B;0a^Eqy9 z8F@dse2&b$ ziT9XuoqM@)pViDurap}RVdUD}uM_z?_Z-W->8!i(ezG`!IP)7k*S~Kctg6c32b}dn z>aX-Z!}`ZuG0!vcIC&nL(cgqTfjMdTiG8bZFqXy!?2p1woXh!XWRsV2{$=Xtsc$1Y zk+V4W3AsDjLGQOU@m5z}iP7Xp@)>eDvU;cgo?1}%e-YhZi;mw!yRV|@Z?QZ1I<|Z- zb!WW%SF+zPaV*&tZ~c+_8`k5=QS4uh4}MBtp%3Cbe1LsFN_`rpq17j;SI0WcAH}?) zc#!q4Jl6xV`YikR{}8L)>$&=KHuQ}oTQhGG{h>SgPWOOmi>R& zKZ?0F%(=(@aORoi=RVBY!oJ(=+fAPX^S788sUe5Gm4&$&PqxEvdY)muJnLo1D=-YZ z(_agl(0`uwH`K4=e!ZTd|Bo~y@E<-YVx$6dz16Y8VrgqJ*HWy5ov2?fD)mF;59mbw z8K&TD{J{Kvd)XQ+=Ff#uM&xSkW`qnt3_R`M*enT_Neva6ls^3>nc zzXI#ix0LlJ)WgV@6RGzkSE2td7GeD@=bYl4H8>ti;ggy&KNUw{UCfVHeWY(T z2BHrx;`zp5Z)}NG&;q|W%De}78n@y?9F0A&Il7@W{w*!@axoM4<0?$TC=AEuSRKn? zVf%K<+1LSX@UFY8FT);ai&rbjdIB~? zf4=8y@fo_5mHs%4=RKSuoAc{rS3HlU%E`X=I0GMG@$$0X5?A6)w5TBKy>KOFV^tSf zABZVf!By(h@C~|GlzJ(icK|sFf4a%~PVxcrXYv?wFjm8FwTx8so|>vpZE*$epgtQ1 zh5TgQiup~Mmsn5gr5cOv$X)1jY9aMn&BV*i#aQgnNOB~7 zPMqsWeLv=JB7OUDAm>eC?n&OuT<&FzuXwIStPjPd>|4fj9b(>N>XmtpGu-C`^WN*v z$MAWSW^Oy~)1Eo*JXfNAp1t*a)dO^HDY;lTBlWzoulf=wdUX-=wGyqnie<=M$#*(P zJyOpx>_5Z)7@R?ULa3~}hKRw;Kg4fBj;x_=K_7hd0u1A+1Xn5Mc_%+*ZlXMI?DRtPND~WzPzts z?(Kp<+ezOl?1?V;nftBB;W(A&b7~{|TjN;Vi1D1$f#=JjUYPgM7Gv-{pVwaUM&3sZ zPUATfdA@#pFaBUd`mXc&UFLmESy{$Zr)o=93j3PC{AU49P0%JNc}J-4wLLZTwFI;TpcMIv2V>t z$+ehQmAV!8S-}1JF)wI{^uM9+{7}iS`iaM|3H|3dZyfca{iSa$_qs#g#hgv#GVE*0 z`Mo%=Gxusu|8MSX$NDh#zu=y|nNx@QI{Iexm3#c+9u~aUN6g*D{fD#ulX@t9TL#Jg zR?KO|Ip3)}QnzN#N1o#*pW{_N=UdG8=lz`Je$%Pvr+$)olX;b&{JU`8V7@;Aqm7hDr`qaPv=}i;3?`f50lnYQw~6&~n1goAnNEM5 z7$cS5r?zUDByOK8uAe0?pguKDa)){18}bJ|&#?au{l;@7+hTz+lFMN|+&xq3mt)0s zI0oBb1^mN3Pv8aik0t*bD|2p6758%Q+VSMsV%cfp9o9{#SK+<^c$|5+dA=y-&R||K zp0_ja!5#lik@;6}4Mt)BmcS2_xgU~&*?OI5_vPOW=;&xGbK^>b>tqI^u45R!}mUr=bT7i9nSsCyp#Bc z?`5TNGPf(v!aev7tBmK~I2Dhg5uZaf48a)u&AqyFPj8+pd5Mt7~u4P~MROy?*yx;7*#q)IM`LA&P zE%rU;-b1*b-zJ$eo%L+KSGj!twyR}*8qe93Jb?2?lQ-i-v|c0onqUd~^YVGvZsz{1 zx8nJxaDQ{|d64zfJm&}A$4l<>i+daKoS*4;Un}#2Ij0YKF1j=SDEU2>=J}iKF;XEO z^;G13(I0K_`97)d!)e$BJ@D&Z={tl|uo+t7UCv9zXe^FTcgvhc`sdAXujzOV^X-y) zZH&WAG-ZEv?1k%at$wZ{t?Q{z7xmxA+tyPn&;gHLka}ONe~ElVd~sOpd_~+to{Y~9 zN&TZf$1r~nIS$*SGk!WKeJijfI$)7AvL1RsJdeqkeOc-SGR1!6TI4~v3U@H?3(vJ1 zud{B(bEPoHEKBCP;Pq>gS7AZ!ag_c+)Lob}^{VvW;C(cp-ky3b`U~JF=9OVR8;@cN zjz2GRqt1z^PK({nif=h5;gsb3tb5@~j9@(gUGUjS*|!!W@c?sO$mO~3s}s^co%OBc z(ddVkc;&eC&%st$2(KQK_1PGR4*2Y-tZ&2N=!IW0WPLw2;+}Ejws?i_^)eiG-AMoU zMt4?TH^rl5UtFxe2Zr^-H^gu>#rmwj!Q!`!RA!IP>W-dga5mn(t#hBw>I+W5d4_&n zHz$XZN8^25&3YR7IN1|BqQxB}{ofbRS$)&KU)EWLWQ+C5t8taC=ik&>P0tlez7S78 z5qn@`)~DW=dMaK*&j(VkLT*Qn!KauvNBZVI6}!-X?m2U*_oi>>W2ql{BsRtT)Z0Fj zx)JrMJkP#|QqR06rej~~P03|&+g<4!kD<7j`M;Ta`@i`Z#68@(w;l7{d0*#vjt{IW z-sfZHmgl)gVlC>|+3%%4kHEZLRCmmHt^XWesEabf%erpJk>s#QCQ` z$*gZ+ecvmoFMBJ-e-L+*|KNZ(Qg8R)9NfjcCd|7+pEvv5KgzyZ^q1m3SFi@>mEj%* z*nfxmQ0jhqPGIvcYBkQ({|{M`Lb@m?d|gNKZXA!z&4(F$+2lD=gaj;{Er zrK}&qcx;0X__T%et;KL`hE>r4Gn-3)9M-}Q&7_`+fA!~Q_}pwii5?h$;W!rK+1C>r z;IF1KcLJ8icL7q*z}Yzezxm{?&5 z1TQw0z8TmY&vL(4*z~i!uVlQ3rN2l$1}~%4SE&c#dVGV<-(OW+?KOV+BKc!w9hvO+M^h?$o;~2bz#eU0r3!H>^u-qS655r{qh;{zTdNl4p^M6ur zk4bnQos@hI12F|3V>KgLABmgr0ah`V_2IYyv$2witPjQYn2nW9Wjzu%<72FmN7iF- zC%(dZd1XBwkKi|KkWbdf;TFus^7&=G7tX`uSlCR~TjMy~id7rS`Y&=VbIJWN8K0wT z0a@>a)6u-3)MGFQ8x@lJ9qeTxIR`rzmV6kCSxWALYw$5TS;=|_9F5EIK9(#ZeQhuj z7vpWTwU)jXI0Wb6F1(39(4na8tBXA_4mV*Ye#6qmWM4-dk12Qse_^fS(%&A3;U#>5 zrZ&=78f#%k+>K8$$X5Edqm`ZHAvhDa;2r#lVfNBL79XOggVYz|4zw*H^#~k~i*P4i zLVLcKCb+ke?5|K#9Ef}H4>ll5)P{>ECRWjzXa;d`v&DC_-jBR;{hWn{evuEQr- z!AaJ8<3@arZe?XX99Q5?w04&D7C048ph-DduZuCb4}YLrdFktp^YA?W!$FOt&%1)y zAJ^b5v~rR4Xnc%4T&4aLJt|5bhllVfTDi%3YaEGd@FAL2l0GjC!7;cTk6|trbeDZq zF$BkB3SPlqSiZ9CYl8!D8s?%&73nLDwJ-!n;sV@-S*Sc@zauulF1Q{gzLX}MiaXmSX+ztogSJrEhkCCr-GFI=)cT;UrT^?NhCr`MguBR#}}toLF6GU{)5UzzM{`QLN%e%|zw{g=5{ zG;;#E|8n-7<-BWP7qN>oa*zOSo@S ztjzN?VqLNC3(xV8^J-&MA7d4EvzuxfA*PaD$lu8Q$(iIe`d)^84axa1gnA6#!I^r0 z&XaB`3+?+Fem=UX)c(fm%~5TA5DD@ zMo{-8w;+eJZ!FHoZ2FF)Ert#>R*ptts?Gq>k^Ezjaa}D$6(eFJ{ ze^1(ksVjP)!ELK)bMoIlG^?IWuKcXH_y*T|lm{$c?v2IEKRQldBC-Fa7 z?}qJ0%Q;gq8<#RSj{Ei}-(_wU>U){e1uH4->@G z_-mqM^F+~(`t@m&bJ_PQUUC5aCGhbisatbiL;9SjOT7|vXT(V!#eITU-^`rDoR>XA z`kt`9j_fvB>W`*~BbobYrsRjbm+sudjeX6zU*c5hTfqJm%=6_vHjI(=ChV_9zZ-cj z>ob^}%-px!d;U1tpMi&*#N^i{$w)v)`C`>&e6UK7L+ltQM{4t{Sfq zvsQ`Q7mCl9h;x(0rc1?-IE8(kar81-FFsogSRj5wC+4nNBz6B4Vgb%=fo)hH%lf2s z()UDvPKNs$vEGV#FUZ^2KM_3_OTYbUG4;RaC5MyO(bt#yCCey3!&ZKB^MF^=^VY){`ga)TYxXP+(> z-Y#CJ{*!FMJ`eKct#-x?6H8>j&7k7)N4ztcD-=$i7{efMMv4-dnZWXovpXYa@NLumW?Iks+fEJkfY83wyKPkNkvr-t?a!PiFnc1=(Mf+=Tr_$!po?^4~sOi|tsqV&7)wgATLp0J1;p_sO4`6NfA4k05)H7t`Ml zdr{Az&y;#B^(^l7mD~~!;#$^+V|n(kWuD7T{r8uiJ(UHX*De~+Qzc?UtZ>&@sy&CqyMR);CUP@m@48mf!q<;Ogcsq`vcCa+VPrq{$M8M1rT&oIp8ZvDE8oLn&tzVG?2ila zIDSBqWhkFLwWBtm?1mrFQFV(3PC$r{w4#;u6-Ml2@=^kp58C zPqN;c_2%TNj$v z*Z(WIFIHgvHv30mBNN%5MBacs@=ASe9IA9A2XL+n)(ptcf{{J#|Y*$qWE7_R8{(~u`dN2Ti?XUj=NAgK!QO;$HXdq<<^+#2T0%cd_po7N{ZnJg^;( z!ew|2pJ4%S*>~7hjK@IyV^r|WALvSlTL>pgOZ-x_a7rwzVwWO~jKDL&e zL3XPxITiP_J{u$OZxQLchVFGF_eUe1qYdljaW3nBt)%}3rePe0VhyywCzi4=4JTtK z{7_idPvbHiiGk>f#+Yp(`!--K7Drn?_l`IV&*Ihkvj0vK(Yl_vhI%Caqu;BMtoOhq z4504_`7H)Emi}}2r;y|#^gkh=MK{jBivw^qzF|%tKbhl?V{tdWMkjyiYmG6u8MCnt z&%Xzc@Okg3EBhx_5Zhq|{83)&7jQWa#YR{RbIVEpKAeuB=z%79-C6oma5Of+PWAaudsjxzUXR}&T1DndmEh!wkt<$}eG=Hh(}>LB?y`BPiT zrCNyfu@_FlRal7mN67Cx%f5|a;!Uz&N6F<{i=)VCc$mJSA+nyG4fRASeI1&~{+d{T{lVl>n2fV{e;MQ)^yKHL6YFir ztFc~p6QzDcsB}E4pVyF&_b^eJ|00w-wg{K}U8^kns)rcdTmPI}_f^i=rl;g8SQtn3 zl6rgGfM-}=j#2oF^$S=QKeIktpQp<8RfEy2kBN$K?W=a{Y_K)C#!wSwTcxkMHAGCq z$=C@!(F`jMl>R;uV&)jJCHcoF$#sT_(>SLZ>mTV)Wc|@-=`&(|0wzr34aZT{=yJ}>)8{}G&zxzSP|Om2#0@lRh_zln3P1s1@G z%-O}gFY%t&;7IP9!+R;h=dq6a592*8$6NHD7%At^94DspJm={9icW)My%v2tIOiSn z=W?&s^aXSNIPzx9Lti#|3g=r6migPGM1S&gzCWXwcPUcVopJbo=W@?c?0d`i`z-ft zMPCWrLf<3wq8`RRV+@#JqFfsGQzP)^B+2Xbdoa|ulAXs(P9O(iX?#6V)_3Cse9W9y z>~BkbJvj?U;nm49ryPAL8lkSmf`k}XhC|E*04?WZbF5sTxHc*&XAElzSS zc_l8Oe-F7X-k_d`e3kw2)mEbK0{v) zc9|yi=mha0`%jPq@MWT`7o8(^WbXK>lJ9Zeefm>z=nPrEyhIG6erdVnXy)~wC%F!N z$=vVTT&b^N&I2sYeFE_K3h4{y{`SldSs-=&{~YXp?<?P*jN$&3_4#oJqCUX9M_V;1EHtQC=U&VTTyutG&axY&##~(ab z@s;vkYHDVA(Y3i^S9T5le2B^)@&Gw_}-fSub@&oV-(f zcUas>eu71JNxd_BkN!J{}$#QJcv9KP3cqI^Az=M^#3J$^BxEBeI81leO%_}^6SQm%O>jkxdF=il30ptlPTHs zym<72n9I5c>o4`MUxxi*)F0BPSTDhTk!vtK78Tb^4SJqo z&S`v#o9J6WUrBN`48Vh|pCRYRkJRsB4)xOHN;xJfCwZW1frs_|40#W^Aik!)h&&3r zQ?G(ac!Twbhx+etX#-Vpe5>n*T%UYXJ7nKLwGlIL4$gXRqTU}KsO<1kuH;GRgAblb zeFD1Rxu;Sei!xGq@IF3&<|a(0KV1FVYq)!?!RCAy#F9| z3qN4p7gBe|0{H&5eqT|8)H%HNQu0&1Zm1u|`S|+1)XhJLN#qpvO~6pBh6VBTTiLe? z$72vy#5Crbk{`d3eY-Ic`=CGC;Rc>(EVjq0m=AMa$=pLY2m50Hmc*|-M;7<<;61d$ zXzEeCui*crUJ;Ej`<9}}@B*2R+ep7$~4i;40%K1hXq5?_*Su@Utnofur4~HF+M3Ib53CjPRBvm2CJhD{wyf_@8dCCkJE4vw#6D~kADluoJV*H zQ*kCX<@?(UC*U&Nhu84~7Ah|DUC|G_V+=0FU3eAWVL=<_pg)G=1YCiKFdKiMjjhb_ z!XO-mvoRen<2x*DC;O{lAP&VjxC68B3l_JR{odFSV{jGj#Y}vG#tyRI0jpz6?2Y4a z5pKhC_!xg z_$t55%fwx{1jk`dY>Ji98o%e0Irs1wZonBh6gyxobi_RPGOx_Lj5~2L#$q@IpgR`9 z?|FD%cmh)~38SzJHbfV+z|W>K?+#|*dYpm7Fa+zOGn(Uj6Pb4d58`S}z(Lp!ebEu~ z;%j4>cNO>HN=(2Z*c{8F5#Hs`8T)VnwnY!Lz}HI7J%=e6hdr?&I^y4d`tKY1&og&% zKQ6*3Y>(B^8bAJ({Z}v@=U`R5_DA}5;9MMzL0Ao~@zZbFcMW&qe2l_i^g%oP`Aha^ z<3U`8vDgjkV;MBY$3JDxN!)-_u|KxNDrkkDe#rjoxCa;G7!1V*=#2UB<#(BL5z}!l zMqx*+jiu2TpMH}$XK)kF#G%*@z0tI^e9s)QHiqB`Ov2502A`mElsP5P2ixHgOvF?? zjZe_1jLfm;et-0z(+%I}96XNeaVnN#Uv2D!(YOG2;#GW)7EW@mJGQ|7I1N+r9KOT? zWo3UQY>9(#7N+AB{D?)JWxo%0!QnU^*Ww|(f$uPXIhj)ieK80J;1pbrdoUAUpmBMb z=YU?=8vEiTT!wq_3ckWT6=Ys%tcgK55aV$b9>DAP4$WL-URkVz!8jDB<2o$HpMNX3 znyTlo2dfGd#U12n7=_1JKce>=`m^v4_2u*>kb9Az(s!_u-e)#KO~zO^$-T+T$d$>( z$OkbStyyn@wW%*BcO!qt%kHKs$!3IljYV((w!-cBSYT2ue(A@vs22VoL!#|!ub%dju2vg}`9MNA=&z}xhtVIsQG--x~? z)nxx|>M{5Sjqx|j`}+QOA96+BPd@Zxy(_sL^WM|%hOyWgb9Mij9wXFGFL4R^ zHu(s7HaU`PMjnhUaWA@IdJR(*FkpmgQ&Sv>Q*k|>z%$;`ci%@WKz79^^j&1`I_kE* z((gds7uPcx_o4#Thk2DOuYPUK9^-G{4jI!0po2C^?dzN|0#0;XXS4#Rfng|_&s zp6tJY`*10a!%)ueOshzLFe^ z;b?|_SP^S+ziayE$nbMwMt(!iS4-;Ec&;*J2XbEg&_?h3q?tt1t#Tq8Apzm(6A0X8aa zormNM9HW0894o}CdDsoN;H-|O%BM!GI@ei@3=xB|CYHc|!Lt4cPvJ&P#G%*$Yhzg~ zj%N6!gUo%17jO@*#W;+>=2!)-@mqVDmyH>?9%tZi?1c5O0v5*a`h6MR(*rz(+jwuj zSOJUTi%zodI4-8Xf;y-+=(l2 zDtd&Ps{CG)RAKzpRr0Sc;#2Y^+>h(em%4rAXeoX0sE@FYHGUltz0)i@Q0VQuC+VSBW|zIccE zqp&XqV?!)~Gl!Te%WjjDPY=-r|8|#r7uVn@&bG(N8F^0b0xQ==fj>g{Tg9Y&ZK$*WCCt)Y7j1`AU zUtaS40h0INEUbZ+_`JXL9mAzK5(BXkzV0XeXK)S1qATXbvwfw1HIBiK=#9njLxlA2 z!g)9h+h9@r&`0{O;5HnMwXq~V>Mi}paV<{4R`|OYeYh6mFan#PD;C6eJ!St@+=Yv9 z40gjtSOLxPZ8&pqH%`Yv7=%7p5>4c_{)oDSnfFEr)cV&rDbeav$n!)wg@#++#SSCPl#Q$DX(oLh+Z ze`Tzk8;fD|H$+#=sUtt?93be@4r^ zYnX}?u_fBz3f@n1<_^c@ctYPZXI`ATixv}1Rml1{H3f%ZH*AgHbibjm2DvP*)ZW?? zr;g)I+>YPy1x}x6sytrAsi7E#L6{ewf5R)59geS6GI7T=2!QwIBT!H_S$PtYp*>CyjS3^z>2^Hfln0pB?1cq zKaTW?-~T1>-2#7J;7CQU}9~Agjfv*+# zfWS`x9=!67!lUnaXyGaU?T$hT@Zqnzqi_N6SAXM6ahXmdu@KE4u0pIwc zI|}arJo(Ez3LgS|%7^bLd9arxx+zYsL{m#Nm0YCojcNShn-w)nd_!av8gF6d1Ne+v?kem97G8E&;oAV;_#<}} zo(1^8+wLm70`O_Sc~{{LfRFjDy9)0Fe9yb@Dpa3^`SYjlDl7^7N`e1~aKgVuzW-Rh zUoYS97x;34cM9wXe8@e>*T%C7e~WK|pMST4UnTGx1U^;ZcL=;k;A;fFP2m3!_(6e> z0{_Rn`&otm1o+^4o>llJz*qk6vkKn=c<{bw6+*x#z5iK-Yk(jBcXt==1$@o_c6Z?w zfSoV7yYRCV{$+O;ejV^n9(#A;uK{mezq@dJuY!*kc#FXIN%%wL`zZpS5BSRea(Cf1 zfSsq^U3fR(QvL42hXDUByu0vEfNwmwyYQI%P=4Qaci|fZK1pB|@b8{~cVQo}@UpuL zuNL?gf$tOe-2(qg;PV9*o~`12vA`z_d@8}uyQlEY0>2CJX`g>j;RS$?dE`BXw*mgi zqwXoZO5mpeZ|dGt_%nh3{y7gVyzJ6}rgU%N?*u;Teze#5 zdkgCVpCE8v;H`k2OZOJ`0bld&_ZA-ZJjnUe_ZB{kZ-OoPJ}Yoe;8zO#J)yft;41|F zion~2?oEK5zrMHdOo2Zv@LdEyac|-B^A-G7fj0~M&jOz;@Ua3PF7T5Q|APX*4ft1n z@qLBY2>ca+&lC6|z-K?{KGZ1%ANm3X-z(q$Q{cx0J_F%TY2R14Mc`$DFBbS3fxjd0 zLjphNg(}{c2wWHZ*9d&Hz-tJ9`y1~oToial;MWM8dq9OhUf{z8eoVsuK;YX2-Y4PD z5O^r?brSxq^8G{deUp6OE#C(MUjqCW{^@;%x4a1T?ql~A{)@n~0%rt1R^aCf{By)3 z`o4U>UA|u{@L7WY34wnA_?~ZlcHwO=R`6#9e(p=u_pyAxRN!9<{of1xLcu>t;4=mO zdx`(e^8Nn^yhY%iz&{eW0s05O|Jj9kfiD2O>4%?P_+EiOC9o#2EAX9wfAQL97yew} zF9`gCAB6t?{Mm)C61WC<@=ebv+#>L;0)JfKa|M2n!wirKJc;U6y7ZGPXK?l_T0jI z1^%tTN4`|y9}jqN^4!9U1%9W%P~a~MJTGuwfB!K0!9RL#VOHSd1^zw43I9m>{ww)@ zzrY_5{E@(hz>mEQftf!`?bYXv?|;G+b7j=(<>KEEaKmju2>;EM$Q zfWQ-h`vPwhc(cGofnP1~%LP7E;71`p$^Cl*-z@Ow1inJx3kCiO@<#w*@{$;EupZ;I|8WlfZ`we5}A975Hp{eRA%FMJW; zuYUCY!uJsT#QlX$fsYs161Xhzd4Ny*)cu8@7Wh>^j(+j;o>%x1fqx1-eSbvYLj?a; z`F^j!lHj|54}9tK3TFg9Rp9zhVBCJ<^9tW9@Fl?0_v-}SDex;K{NVyWD){#cYzh9? z<@-kk&Itag0zVG;_Ln}d@Bx7j3Ve^iUlaJ_0)I~60|GC;5_ZMUKd4k-AO9r!)h~a3VeO|BoE7*A!QUb9g#!OZ;KPLOZSwt9^8HQn{blm~UZg|( z-y-nU0)J58fzTaGyw?ky5%>gwUn=nP1zr$%N#b7@_>aQ(X%hZH`Tib+|J{>cQ20f_ zSAN|K3jg81DfkNc{wsmE3I6K^wgp}j_yVC@mhXE6K0@FR3w*u6-xv4^fuH}=D&2n& zKKBURl<+$c{)K<{g2Fco+!t6C_&kB%A@Iope+Tf5k9}d`7X-ds;P%e||HKy-mIeL; z;qmP+183G>!J<)wi;D-dhT*4nM@Yw=iAmQIHurIJC z@ErnwQQ&I?K2qZUM}hw&@WTRMFYq@7eyhNiz%P0=`mx77P`C#8lqWn;_#T1x3;aoe zErB}%R|S5pz^@SaD*{7-U-TOA|G@_ee}->@|0M7e0{^GL_X=DE{WE^~fx@!DuNHVS z;Kv_)pm4jumcZ{2_#A;hBk)%R{;t3~{yXL=fAK)!QvyHlb?W=k0>4V&*9-h>q5A`Y z?-KZCfo~A_N`c=f@y-hT+n-hZ|BZxyiNF^Ne1gDFyjJ8Ac$>tl3ZJrke}lj+flrh0 zj==90_-uhk!vCf6y({0}BJgJfzbfA)fo~A}TLiva;DZ7`DDdL~KOl1duE4hn{5gTI z6!;Q>?-ThyB(NaxITHR1fln8>D{x2PO#&AMK1twX1^!!s|A=y@^8SdxM@Tx475GGf zvjQ6eTLP~O{CO`|K1$&K`>TrYUkZGez*h^rSKxubb%Bo)__+fAQ1bUCfiD!;5m*s; zLGt~{Usmbth+@bd)z#T!-pw+eivz`F%r7I;qJ69qn8;9tH$#eavu zpA`5#0z-j|0v{#tic2u zRPb-)`yL6uQ@(2gL*esSq5q_$(~@+bAn=g_{|0&>`TkFVZxi?y3I9V$=WB%Dr{w!( z68^tSx~~)b4+#Dv0v9Fx86ww@2>eBXzc29b1wK~fT^4vr;4ce2tK$jZcL{uzz;D%Z zi98kgzV|(tkDYyS;hT{Ug1_-D1%E`~%Qy{FdT-ufT5;xGV5xfklD;LEys#ep2N9pul$t{CR;d7x-|INuhGFHfwjTy7&1Sn^ z>xXH$o5ETn>}H3ox4UPeelMF~CoRZ9t~T2(Cv8S-hW%Qj*00&oSGys^tgNnXb=!MU z(}}be_WIrSwe-OCsMP@1UYN#}0@tH%ub&loK0HYcI~(@TY;D;B5~fzavfphVA;EUD z?P!idJzWv1c@%EedRII?9DCu(PNgtrW3t3ZwmlzDJy{bO_7!DT1sxy zN|5PQU0Ox4__A-+nql9q`-rg>_3HcHBK(9Fu_g*lZCVQIx?q0fcaF4fRVJXumTk7!2v`n7~+op7fvxFHFhUu-qoHMF_l z_EO32I-~to*x=4|>zG65lA)V5>R}HLDg1o3KN|$aBL3G$8wwGmRE(osG zZiK;Ztq1gR8Gpw+L3KW`VwV<$a<|s3wd!F|+e7;fqE;{L_DAG3dsypKDD@IjjOqcp z(WtdwsS~PLKd5yfXARv}rCu%rx6FB|_1j%Sl*?Q5>y@3Avj~}MhP_^;x)2cETtGbM zI<=@JgSu6#?9!7^CeELzXNpZ^M?ExjF!sexHLPVsJtW-BB-npI6 zl3dSGmQ`kQ3wBCtxm;7eh*7qwe9w$j^( z`u%2DZZ)Es6LR6G-#OBZU@PL~ZPO{EpLfCsg;o2FRrGh)&~WXS^KP9OIk> zDCTvT?I{MKMz43ZF7`-f|0yf z+F0NEmZMs$54*ctEGc~{d$O#o0iR}ZrP0_9F-jkYVtAIf&K+~L@JN?5;m znNj)Z4cJMf++>6c9n2{bY^X*hvDMmfxYJI-qY@{vRNs0_ zs`XmSpNgPKrZdt3!U%0XF2kMn&82fZFN#dTZk;R6w>y`EI&72LA!ikj3WastQ`h*{2!f+)01o+s~AhEF=RMI6jU;#yk5Bwz(j@| zrNh>~>a=b?e-^dS?wzb$DDK5MqNY+^JveGz>G|}>s`n8?_%q0q#c*p3!VEK((D-9B zcI8GJbZl^D4)kQgE?E-$CM;Xr(=uVndiZBBVW*JeK_<>p!o=Y|%N)de6-*sHjm<4|TedjKP-kGag4^B0S_b3ID2*v$edQ{C z+u=US#`n3wMTrzx(28$$ZZ(hgqeRw>@n&bK(o@vs7P)I2_Ztm)HmM#0lco%XIGUg_ z(T<8dK+$1$11{O7O3)6bVbTBIX(!VmIwu_(k~p&|;%l=8b%DG4MKk!5H=usl**aIR z&ZzFLIAfGnoG0h$c}#Ley=5L>&O0;FGpj3SFtnM9EIoGtPkc_4*_6R=q6l@B}pYZ9hB zKGPiN22Dn_gsh`M)5JM5c34wI+ra}b4#v7c9qOEPsJ);U*1GkB05c*s85XGxo!Q)q zONfeuk*gPXlE}5Ss)IaVTw1$zCpfclVfEZvdG*3tc{`Y&M;$)upi;o`Da^{ZZoBao zE8$5{3QF^pcKM{fHX}vgp>=K0=!KOodX6Ny#{2Y(=Z~7rvEiV4wi zmRB)dXCrP7He92;RadRb;OFa2s9W-8p?ffn_sh!9XrcSCj`tJPv2qM$T={{zphTD_ zo*lzeqlst7@YLw5G_$348;dLGb}FAdD{WGd$gC=2f0Whw)ghRC$N>4qIQpc zr;KexU77k!n8p&EwB5aC`>OPC6S7|&j056cEq;)nGnkxzAL6UrBt)}(yAB1Xs6 zsWk%3@PjrxY0}GB+*@rml|fYqV(;Tlurq^R3H|)mIrLAkfbnnJF8DIgJOGI7OLnzV z9Me+;6VJQtt6>sWt|m%z(8N(cAP0M`PR{!toXl7(3e#nS^$qcgvnns5n2J`$qEd#v zz>qyeoL{UQ?ol5(cOFI?Mu<`{Uu{P95PdzRk?K{f&e9SDg2l@}i!#vua$9R48ZuTRAQ`*XFghwT0TA=nsmT~y@AJOl2YgFRy}plx2=w9oN;9isPqli zQHMdh>M(du9aUX>#~rt{IFt8Niqno3Xkx`)@)S$owqh@(D%M~f#TvA$ScCTzdr9YG zGR4MhCRWEmi(95zxSfET9!_?q#!v>8o#UCHg&{>NZW=O9k)@I{sAH{qKftuM8DPLW zj9ToO4{l$exx(35$B^f#!r98YgFKH#5?-C=W&PsJT1d;eT`U-tw+^;s>gkf`sXQiX zY2jGE5(X{U**vfC5}DN$)qbtpFGp!yFbi%r*}y+@w6_;_(~>I9tdh;HxwX5T2Qi?X ze3eQ}X)-r}c5V%Or_z`#>4Y*gVTS(N6dImth%pGGu?2(faV!hY-G5b z4cLy^DPqXpK3Bzh(gGWBTnBDib7y#rtgK#eDuzO?yS0UpaAPMa;lxfsZj~Hlap`g= z+_(Jdjb4ANG{eZc)Ee@&AJzMCJ~%FM8k`c*d)@k0sl?G6alIYD0G(pgzj>>iCaOE@ z&1_i3qUGA-dBGg{pIl+FCJcHwn`ye; zT3t(0Zmr&$f?VHpkgSER%Btft$jmTHu$3yod6%!EtU6*1X1l%Ox+s{#_R1}exaUg? z8`17|?P^flMcsg9AJ8U7WiJ*>y`$YdI7@>zoPM!$YhaXF9i>j&7p0{SiZO?sMptss z&F_)RHV5It5q3W1VyPMo>bYM0EG>#M%;J=#jrqgcl`yzmgYSsVX)Vj3NV8#kFAv?^ ze%QyLAYO=pa?B|o%du?F8ca)`hVqFT1BOr<-{4?Ea-`(R()=+kX6K7FYJzH_w=`!_TJ1g5~-5%_G zac-y9-LJ)43$flFue_2rcPi`a%45$z$(EtrCHxU~yX~&>#A6A9QB?2c=b=q{7#_l@ zu0!zA!NNMnKu9kn4=SaEnrZRBTI;s3tYcEZP7T$wIsc*V$FHgF+jb_B`DM>JkF8<-7iFM*W}+6>D(2?ps^ zudDN>s7|jD_n&jr&&n`VEIA?DytLui%`ioGsh7cqB%5@e_wkf{vo(#>OluqtW?ti< z&BVq<$LoT#5JMeGpc4yosUjcn!ysK~nZ*(dLpoGy zi_~6#D!Odk9GN(7jtt(-k%fb zkcMfi7Iyu$kGl16p0@wRO(GebUe~qTAwh41P6owdCxVRN$)GsaB1ESxa!1`wEVr*= z8iU3PM@PJIG2YXr>UEMnz3ydE4=k%BbCdIwumPDcc~8bOnJIo=hKj4&+sF0Y}vcgfw{dtpxQ-7q)zUYL$onn~n7I4%vyPkMwwSxS!)=PDz3 zuz+#i(qqSkOGQQ1IXy$FYt%FudGLtr-cZMk^AaPp^coS%8zVHuG9=upb+J#lI7@>L z_aG#4Vi4rUluAyURmu5x?%?uewJF#lo8xXKo2}W@=_g>t9GJpVEH_m$>iIAq_eXn= zc?nLZT4SSjE$pte_^=%{ylPmdHkgR*M_%GQjTxIAV~HfB+ck=tqkUCAS=qmQgft=!?!pA&nr+w>fw{IO(18xyX5`^+m5F%-S#_TNP-Pd}P zduBk{Iru1P(`GaH*!;t^$7|K=>eKX4MQ*P*xb#nyfHnEG-DwA^BJu zQY#QXC?87$3OXx{@{tvW?570*n~{&5HZDTA1{b+|AWiyxoXTmo-OcN92u6$S(~r(J z^f(Gum|Klnx8ZMYj|o%&`$twUoWE4w#=7ZkTjfe)ue?}S=Ps?m9GkPZ%jKZ5xpKD5 zbZmJPOK#MI@uNoLN4-3L)ZX|}`(sDl8$Yjm@9wvdL3*m`$Fl#cc9aJ!X@qYO)YWCwS&sA7@8t2TYSLPI0hn?IXTy#X(9p z?%+1sbim3%RS$6P%fnqvp}Xi3sw8*XBvu?-BYi1Z6pvPL8Khp0NFFb~Liy1ZHZ``Z z56+FpQgA*`L3>OE>vCnqd0YkOa}~75Rj?k{G+|YFBx{7m`;1+A6SJ|M_QlHi9d~qJ zi~0xdJy|;k-LQAiZsK6rYO{9OSyclx?1FV=W(%Uy+G^J7G?xbcwi7G_y8%G)3>r3r z!vdG+Y#h-hI_w#z331|^Se>V{Z%u4PK&Z*b&S874Tib8X%zD`MTEAaw&N!wxh_}P2 zg?;Lc8D~D`1h_Np9c(9n9o*qlh-9x6&!5**{cdrl*2Mn57TqL;{dD+K?cAX$GEEN* zaKS?c(L8OaYsH)GtR%=9>f>?`ikW1-7-3PWWt{MK!o!cFYP}4p;UP*93r?aGZ0sj;q>P=T#o{eT zaZ$~#;>;3VZ?b@;^E2&}vTPJXf!b7?vukCYHRNtCtaYzAR8hRU(@JjPOuOH2A3B6)BdJYz6HXTRxlFr`!Pd*tX6+<8 zqbfzGxV4l(^$bqBds9i=rPCY}ElPQd|d?S8MfykdE~hXBr{yN8{g8 znXJH~3OvL6!&H9kP_=O^BXpLxwqOUa3g>-==dIX$#I1GI!SxL+jVvM?iaFjyw|!1l z@{=p#Gimo%%_MfC`f?*-v(wHbx73Aenp6Teu67H@YFZ`@q-S*bDxHYa5xL9_Q{&l< zSsBl6jEYOkM2w3{&JKLW+$NU2p(3Jf3%E>*PKcW0TwC+3Hg(S#QKX(eif}Ig0@c~0 zti!6jVQ0`T1#F$6(@FN2x6;AZDJ-?P_YJ9wO>omr1h>Fp4I8!0*ty2-!H)r-`Ua{% z$gIxeMnJy7!^A>3MM)gMukej+J~!H=yJ?cA(LH&K38m*p+=R2)$I<36i+`g{!R@m%Ml}_T)ZJFCX{%_fIJ;iiytuI=7vFHR`Ru9crt3vr z&8*aPq|Q2njn9nDL%C03XRX~BW#5hsxvSf&t_PEmvZLLu9)v%8v2{Ii8USN&PvS1N z>M;*2oy=^v`{>=VS$1#B=)*2ZoPflZj;J5td?yY~;M&54o!UOqT-;pS#EI_>Qk`{n zfE83O&UB7?2iTSm3y)3<%-UP?iV2=r{+t4rzQ==3DkLOPdoQhhkLo%`EL{dY%o}k# zBPobR)5>7~{oz_q%FAqy%v@HP@#~0im>Y>h29x~<3i?A5Tf-5 z9er7IIzH&ut`-6cJL%#!R2^%-({p1wp)pTvl&~TVMyr%~5gT)|Alhq~6ljtsz*v zr*~PD;p#ZO%c89=G4b!RST^@Rz%{1MP31jz8K2vcDmoFbf3Djs%=HbEi0fVw(bjr1 zmqg&2U3I#9+#W!kz>nEXBrNsMJJY^hU~-A#>jfrf6(7x?Ox-b?$tChmyHCPUw=@4x z{zNNyL$!4#QGYvZ@6g8@2jdo00Mz z+nV}YhpWM4n)CJSd8)a7zVB!^o}OYFjo+3dg+kQB41IOOALiKu{8Ul3jJYn(fmx2% zMVtyNlW$K#=19cI|#dn+B3rDJMpw#OBqxXiOeGaK#K z_Iq2r|5>-4xUIO(tK*+p9V@J{cKpS^9-iq#H*;95Rd#3F`bh{bY z%qS{l>OqRLct@ZQw_CG%CA_**!CeAIsaV^Lq6V&GPoq4@O^LHzSv==&YImdSa9rj{ zKS4V{f&^`r3|473E+6&!XZXd17B0}SRlLGsygxq`-@?Tf?p?qV;|SNY{XO_v$78K>EgdDx?9##Y$D%`G5%RR{XE!aoG#|7;0 z^=8yDRmTs}RoceWy)moZw&S?hIOkemLh{b)J@}4%4siga-o+6F=Z<41rY1;Vs!Aoz z79)Kf%3*@Ym?Kpj<7)lF_T~zDDVjW`2Mp~4xfJ%h=mpwQuh(u>+f7{iX{%)ucb3Gb zo9zIca`JZx3u+tZmq;o&7+0}}0!zVI@WQ3Y1j86lYh#mb{WJTwEO* zVh^w9=f%0zGgYjzv}g%BnXVUV*!clAzo>q+8`ZP;*`W?UCm`lGzj`Jj@oL>vhJLW& zmc~X%{0>d^XOc;;R1@-6y&5TGY4TR7GA86DY*OATcKo^( zLm1DmrpSx-o+u!uzm$;oQkuM%{AMDN)8xIBE*YUyB)gO$*?CWl;v6~}woFu^S=)DT zeDg9M2(ey%fu$nPyts9xxPT3+Vqi?bW}bU8PXc|26ms9fZ$S2Vz{M14%P&AVZt7EF zF(4nM-Pze`sZB4uid4gFOYjS}B4YvR(qtsU@~ztm!3z8kMB}P1BKp zg=0NB=%>?DOscd5FXgSNu!fyR!;fkqQRoIQcGh8{+-LP#fXx ztxVga8@GH0gcK&a_7F;qb|eWglEf&$!$h=MfIL6@R12{z2~sIu)XR?6l2yEo_SII8 zx0=R<11l9T0bz0radGvwd0oh=q*PhQ3$t0BRJ}qb|5Oo zw2RuPr3wzPDTygpkCYbC>tj0u-SDO}i0?z>0lWH~E@uy&Xt1Y_1#)RKBHH5_vq2PR zPKq1?4Db9I_Mdy3|r06EPa6-o#EGZUF zaA4BcaT1<$we~gjF*%LMu~! zTQx%=teT+_I+yC(su>Dl)eMc$HA8*JWiOvv<@{-ChJ1RVx^y|z)C~D_GGl56hnkup zpN>>k&EQ~DGx*c08S<^`qt7gczlPgm*I8@gR)&23Kh{550S63cf z92u~S)kgH_5=lW|S;HZqZ#$fZoZ2xS7*TJFa}y>Ur6(-t6LuWjJ{(H>>3NSI%o+@c z7$XqC;uSkJn89p1!Sg^eGP;yN*U8-2rJcS(m+L(vR98$G8VVZGF@9o?2Rdm<85e;c zbzz^hyJlcgMAhbM-lC$J;W>5C**!E)+Yp-4`mQe50@v@Oxf?>!&`NW4*iCfAY zJaMqm4Xju5UFT@s6sFDhM4{_|1Y@fT?NRSV92GCcqqwk(`6^7$F8f0%5f!kMflndr zMfRXq!#SO$wH5qYD7i^XD~-GYdmDy^v;>IqjdG&wF^9>^sl=~97m_bc^)e@9YT zFo8nl17Ix}-T+ zCgzkvk7faAQ2`w|U<4Sp<)umejY4H_iZn|4lvR}7u!Txxlhojvo@6%TYvUJqQZN%z0gided`g7WMzz#2w`v{K^Vjd z>`C>Z${=Y38t2594>Ry7P6>2C%~%gN$3#*clq`v{$3S95@e(+7Z<^FprsB#{r}L7S+~Tr?9%ylPXP3)sxi320u3*Lwh<`j?e%p_ot@Q{4U=N$rrYc=dsZyu3g8F24O1Ha;s3xg zGrWSx+>s?SY+iB{yBO=Mhlkw_r=F90`trqNoE;yH!HOT-7^GQhMPyi8wWwd&w3<#I zPs*9d{qRJZK1J5H78jzGAa}^BWSvoy@v6qS#lZnwXNDwEnoBTd*go*5^Vfu{W1Mlm!Wj0;u2S3pdp7prwq#TB_=up3=!mmtL5?GRB9 zuMjXv*?(^_q9Uhs^?*WkFLrsuc!=c@mtjy@TiLN}ON}KDh_{p@C?p-4lrH7;Dw7XIz(<$J#)dPSckYxfAz{-1E zVk{U_TA`-!I2iI+fw8JM3}4a*@#j$oRZ7jmR20%Dhp3SvuJ`OaS0PsFdI^eSn9AvW z#yoYoG{_r|gLJX$fKRoFTs&XM4t7J(9qV~0rBb7dOoKzLe3;xAoZa&gHJumTXK#w3 zHaMRe(+)T*==hzX4o^Cm>-*mU`KYN6SjK`d#<521+$yG$ zAdC?!2xG@;L~P0m!dQM95gUIR5!-ee5u0~{=$Ab?jD4pmViQjgjt@g{*W>JPP4-4u z#;FQqdpZ~`a}T!*lpfX$T0-g$ER2lDEA_>jA!26N;fbOChn$G2)K#Uu5?+IkQ|cTH z^+U}04pD3NFc`twm2QsOwV5~4m#G`{Whw@LSzZ8(fvGG+#52Np?r38YeVI3RWLo9e z#MBRqw^;gb05<4)I^E$Y9eYzr6_XqiVqwLTOb!_|Z6pFyx%HPXs;TWnVX8WRDM5{h zS3>MNNShiEwP^(OWm*7##nqp_xU{*$RC(6p7KgH0 z*y{v#AX=y6ui~znoOEXBi%oV?2i+TC4M&8Eb44HML3jg;ZUphz;d%LqR%Oy>C)mSw zOD6h6N(zWq4>ZDPgfP8>Xiqf8pRq3Vm!FU~!W+v-TWNbunERq!**m1Rav96bBB5kd zu&(|-vF!R#D>TZ!4*FQFBV9RReeB@~BrjrnD_$u^xgDVEt+vYTFqMq5nH3&}g>7$> z{CXb{xviSvv94Nv5KZs~2KNuzmX&97MGnyY?~9G^Gro#;fC>q(pVgAoprqud2r@_= zghyQ*2Z-tk(!d1y{fSpz?a74I!KVDDnb`0xuhI}R0VkT*{y}~ zgh!k|KzBqF}z^M29~+v_@VPh6=2TM}5X4e*9^=K!u7s7keV3s|mXV6hCx* zDni_iC_MW+#IH*Ck4fdAx%!c9iSoplF?zv5u``CJe8+aD`ZlJ8`ZmUe`ew_)vhoFM zrtlWRazfZxuRzqm$+JdVm9V`UQsF(cGpkpOeYdc}8iPQ68&bJC0eza8v{!fmJiKOiTGm6BWLXSHZIdzWv7IEZ?~_m@di!F_xUz3W!@wmV@ToV zgC^Kslq%u8NISRy(jz03Lk01r?%26ds~)Uen7{pS6~jL*l&4N0le`aa{2TFXB!_n_JxS6!S|aEiP>k)5Y2=$~mo3s^xe{ZaE%~Zo&3Y zeEqYJliesJ^_o80uLM%P1#s$y0HTPG%3BmT3fPmY6=D)}5)B^*C0ViPJRqI9_fQ@Y zT`}tLY2m6;^kFL2Chdvk?+OpntRwEW6tag)45G$*yGv~dYX~ZwYw1d>-4afWrL5Bx z1wurP{6bf^Nt+Ori?04-6k0k*))h{F8@V)Q3tN6v(OZ(DypKAX5vh)~mezbIz^hDz z@|q6IvW|HNHE=%IK}=a6y!|J^fky}rdkd>PO$ZLLs5!aqkeP^vC_U zrn1^yOo99pO+^Jj0gSkb_C3*-79#PGOw0l7t`pLj#R~5NL#@Hp46wDO@1;(;N!$LF zwuvoJpxQu}Y}F@&EMxmLY;h65kGx(xIfJ#}D^!mp37~E{;My6ZDCeuIm7N`g%_?3t z3Iigsk5PCzEs42BS3t0!DP$L$1{9T+VMpzIBvwFe;uwmHVX17Cn!GVR{iK?%IKui^ zsnCk}8Csq2aAk5&Q>2&*%JMKYtTPGfVoa8Ty3nPv&;|$9T%zV-$fZ^zldc|`kOm@` zj)x{qMhc}fw2Fj&ReI|<(a6lUv3U?ZI`Xp7-rp$B(CW)=`lH|0KNoELLX1Dc z<^nMwM4w)UQ!I{-XG>oAY)QgNF(evZXh+Nf?ag2-f*zteI>u%WI%mN@)gdP(KE>F$ z9koD5KOf$@W40?ZEQtNX4APmes+?@)u$+3T9EL9FAIFBcOU)-TVW`*{?N+)6v z*03rKL-9donx>?wWX|xNwaACIz6q(!z=l;zEUX(JPY`-!z_=t;IqRoHAWkZrbq1Rk z=UE(6)Jlt4ue2H~wA`*lmAqO+#4VF1GZ6J;mml#{9V81wIDR3{!|^j`9&Ul23{yBN zN-~kLsoK(o*sqLHrUubzTa?k#)o=4LM6D)6o5a&Bi@0d5+q9}22&1Wz9BoWYMbiVr zD3(`;Uy3m*ZSzeOEKYh>(e|OD?eN$do$y8Hy-cGZm9vQo^ITrEp$uARYno_b$=p@) zct|XndJNbMPGEPC>)2=_9)9v(x^9B>Wu;^#L5&s{E6~-Cq-~Wh8)c?dNM$hyQ6M2q zN$9FVSg9%W6Mea%u@JhvTqgQUhhEYMC0P9Fm!(UFqP(Ow-isc?{w>%I1JAT?%em;- zZWFYMEg#0zyXx?YBdu%u1irbv~{ReP4mJ(t~>m?F`uF_ud~L?AxNZjQ+WO&YL> zb(3>Z9+7Te7LlQ#nsIvt+Y@VK{gMYoe&~%k2?Q02rnycpF6oou`WJZUpJ(VO3O>7a z;>^JCbv}u!LVzd6Ec(!!xf`J@Q_2tFDqpL7SB!kH#VEf~Kh`ji!OKx2vs$o};Sw&U zwLZ-ko`tR*qFPJf7W{&|(4oJ(SPO_lw`m8r`*jXWcrgaGASHcZZ^CFpGY#RobJQ|S zp`Lid{r+`+Ed%VFDXhn?8wFKZKcs_E`_~C749gX$l-XB7!SDmqW`+IhC_b2C3PQL114`Y$ zt_hA>nnW>z9f;^^j({ImsT~lCZ3oT|hB0Od$ef^gK5xw*$A(U#V)=*`w&|{{0#>%- z53U~8H&q5mD40NZ zie~dMRfA0zmrQUD-5#B%cF7bj&`m(Ubs7 z4RI9wXrm@L)Qk&`XC1UvP7)b?kgT?|LQz|3$=c#XmnI~nWNkOte_@d_Hl0@OhP7xD zWa!LPx$dD7s|^hfIhNDWCkNS~P*`>-uS6yUrZnRaX{b)-iGUTJ!Pze)HAq-;tH_Cj z6*{2JHMSbSt|ebZdL#D(W*`yMoP+O*+wt`Wbe5n8Kis zp!^Ym_MEuiREiiWH4<%{dp`HuBSJ0QhyTpP5=4@W9w2bY2w{<77K05Y+}lx#RDimD zsvvAoQ7%pj?$9j}4J==&H=}4PNsLmd#Gi_S&5iUBWLx)