From 192e46c32f7baededf8df7b1777f8c5409110e8a Mon Sep 17 00:00:00 2001
From: Parvatha Elangovan
Date: Wed, 28 Feb 2007 15:31:56 +0000
Subject: [PATCH] Enabled compression of TIF image format to j2k by
tifftoimage() and decompression of codestream to TIF image format using
imagetotif(). Modifications in image_to_j2k.c, j2k_to_image.c, convert.c,
convert.h
---
ChangeLog | 1 +
codec/convert.c | 356 ++++++++++++++++++++++++++++++++++++
codec/convert.h | 3 +
codec/image_to_j2k.c | 35 ++--
codec/j2k_to_image.c | 58 ++++--
libopenjpeg/openjpeg.h | 2 +-
libs/libtiff/Tiffcomp.h | 214 ++++++++++++++++++++++
libs/libtiff/Tiffconf.h | 131 ++++++++++++++
libs/libtiff/Tiffiop.h | 287 +++++++++++++++++++++++++++++
libs/libtiff/Version.h | 1 +
libs/libtiff/libtiff.lib | Bin 0 -> 229770 bytes
libs/libtiff/tiff.h | 380 +++++++++++++++++++++++++++++++++++++++
libs/libtiff/tiffio.h | 311 ++++++++++++++++++++++++++++++++
13 files changed, 1751 insertions(+), 28 deletions(-)
create mode 100644 libs/libtiff/Tiffcomp.h
create mode 100644 libs/libtiff/Tiffconf.h
create mode 100644 libs/libtiff/Tiffiop.h
create mode 100644 libs/libtiff/Version.h
create mode 100644 libs/libtiff/libtiff.lib
create mode 100644 libs/libtiff/tiff.h
create mode 100644 libs/libtiff/tiffio.h
diff --git a/ChangeLog b/ChangeLog
index baa216c9..10bf62e0 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -6,6 +6,7 @@ What's New for OpenJPEG
+ : added
February 28, 2007
++ [Parvatha] Enabled compression of TIF image format to j2k by tifftoimage() and decompression of codestream to TIF image format using imagetotif(). Modifications in image_to_j2k.c, j2k_to_image.c, convert.c, convert.h
* [antonin] fixed a bug in context numerotation that prevented the RESET switch to work correctly : mqc_reset_enc in mqc.c
* [Fod] Corrected codec Makefile by adding the compilation of "compat/getopt.c"
diff --git a/codec/convert.c b/codec/convert.c
index 5c84cbdb..3ff6eb88 100644
--- a/codec/convert.c
+++ b/codec/convert.c
@@ -32,6 +32,7 @@
#include
#include
#include "openjpeg.h"
+#include "../libs/libtiff/tiffio.h"
/*
* Get logarithm of an integer and round downwards.
@@ -1063,4 +1064,359 @@ int imagetopnm(opj_image_t * image, const char *outfile) {
return 0;
}
+/* -->> -->> -->> -->>
+ TIFF IMAGE FORMAT
+
+ <<-- <<-- <<-- <<-- */
+
+typedef struct tiff_infoheader{
+ DWORD tiWidth; // Width of Image in pixel
+ DWORD tiHeight; // Height of Image in pixel
+ DWORD tiPhoto; // Photometric
+ WORD tiBps; // Bits per sample
+ WORD tiSf; // Sample Format
+ WORD tiSpp; // Sample per pixel 1-bilevel,gray scale , 2- RGB
+ WORD tiPC; // Planar config (1-Interleaved, 2-Planarcomp)
+}tiff_infoheader_t;
+
+int imagetotif(opj_image_t * image, const char *outfile) {
+ int width, height;
+ int bps,index;
+ TIFF *tif;
+ tdata_t buf;
+ tstrip_t strip;
+ tsize_t strip_size;
+
+ if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx
+ && image->comps[1].dx == image->comps[2].dx
+ && image->comps[0].dy == image->comps[1].dy
+ && image->comps[1].dy == image->comps[2].dy
+ && image->comps[0].prec == image->comps[1].prec
+ && image->comps[1].prec == image->comps[2].prec) {
+
+ /* -->> -->> -->>
+ RGB color
+ <<-- <<-- <<-- */
+
+ tif = TIFFOpen(outfile, "wb");
+ if (!tif) {
+ fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+ return 1;
+ }
+
+ width = image->comps[0].w;
+ height= image->comps[0].h;
+ bps = image->comps[0].prec;
+ /* Set tags */
+ TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
+ TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
+ TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
+ TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
+ TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+ TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+ TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
+ TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
+
+ /* Get a buffer for the data */
+ buf = _TIFFmalloc(TIFFStripSize(tif));
+ index=0;
+ strip_size=0;
+ strip_size=TIFFStripSize(tif);
+ for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+ unsigned char *dat8;
+ int i;
+ dat8 = buf;
+ if (image->comps[0].prec == 8){
+ for (i=0; icomps[0].data[index] ; // R
+ dat8[i+1] = image->comps[1].data[index] ; // G
+ dat8[i+2] = image->comps[2].data[index] ; // B
+ index++;
+ }
+ }else if (image->comps[0].prec == 12){
+ for (i=0; icomps[0].data[index]>>8)<<4 | (image->comps[0].data[index]>>4);
+ dat8[i+1] = (image->comps[0].data[index]<<4)|((image->comps[1].data[index]>>8)& 0x0f);
+ dat8[i+2] = (image->comps[1].data[index]);
+ dat8[i+3] = (image->comps[2].data[index]>>8)<<4 | (image->comps[2].data[index]>>4);
+ dat8[i+4] = (image->comps[2].data[index]<<4)|((image->comps[1].data[index+1]>>8)& 0x0f);
+ dat8[i+5] = (image->comps[0].data[index+1]);
+ dat8[i+6] = (image->comps[1].data[index+1]>>8)<<4 | (image->comps[1].data[index+1]>>4);
+ dat8[i+7] = (image->comps[1].data[index+1]<<4)|((image->comps[2].data[index+1]>>8)& 0x0f);
+ dat8[i+8] = (image->comps[2].data[index+1]);
+ index+=2;
+ }
+ }else if (image->comps[0].prec == 16){
+ for (i=0; icomps[0].data[index];//LSB
+ dat8[i+1] = (image->comps[0].data[index]>> 8);//MSB
+ dat8[i+2] = image->comps[1].data[index];
+ dat8[i+3] = (image->comps[1].data[index]>> 8);
+ dat8[i+4] = image->comps[2].data[index];
+ dat8[i+5] = (image->comps[2].data[index]>> 8);
+ index++;
+ }
+ }else{
+ fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec);
+ fprintf(stderr,"Aborting\n");
+ return 1;
+ }
+ TIFFWriteEncodedStrip(tif, strip, buf, strip_size);
+ }
+ _TIFFfree(buf);
+ TIFFClose(tif);
+ }else if (image->numcomps == 1){
+ /* -->> -->> -->>
+ Black and White
+ <<-- <<-- <<-- */
+
+ tif = TIFFOpen(outfile, "wb");
+ if (!tif) {
+ fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+ return 1;
+ }
+
+ width = image->comps[0].w;
+ height= image->comps[0].h;
+ bps = image->comps[0].prec;
+
+ /* Set tags */
+ TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
+ TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
+ TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
+ TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
+ TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+ TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+ TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
+ TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
+
+ /* Get a buffer for the data */
+ buf = _TIFFmalloc(TIFFStripSize(tif));
+ index = 0;
+ strip_size = 0;
+ strip_size = TIFFStripSize(tif);
+ for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+ unsigned char *dat8;
+ int i;
+ dat8 = buf;
+ if (image->comps[0].prec == 8){
+ for (i=0; icomps[0].data[index] ;
+ index++;
+ }
+ }else if (image->comps[0].prec == 12){
+ for (i = 0; icomps[0].data[index]>>8)<<4 | (image->comps[0].data[index]>>4);
+ dat8[i+1] = (image->comps[0].data[index]<<4)|((image->comps[0].data[index+1]>>8)& 0x0f);
+ dat8[i+2] = (image->comps[0].data[index+1]);
+ index+=2;
+ }
+ }else if (image->comps[0].prec == 16){
+ for (i=0; icomps[0].data[index];
+ dat8[i+1] = (image->comps[0].data[index]>> 8);
+ index++;
+ }
+ }else{
+ fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec);
+ fprintf(stderr,"Aborting\n");
+ return 1;
+ }
+ TIFFWriteEncodedStrip(tif, strip, buf, strip_size);
+ }
+ _TIFFfree(buf);
+ TIFFClose(tif);
+ }else{
+ fprintf(stderr,"False color format. Only RGB & Grayscale has been implemented\n");
+ fprintf(stderr,"Aborting\n");
+ return 1;
+ }
+ return 0;
+}
+
+opj_image_t* tiftoimage(char *filename, opj_cparameters_t *parameters)
+{
+ int subsampling_dx = parameters->subsampling_dx;
+ int subsampling_dy = parameters->subsampling_dy;
+ TIFF *tif;
+ tiff_infoheader_t Info;
+ tdata_t buf;
+ tstrip_t strip;
+ tsize_t strip_size;
+ int j, numcomps, w, h,index;
+ OPJ_COLOR_SPACE color_space;
+ opj_image_cmptparm_t cmptparm[3];
+ opj_image_t * image = NULL;
+
+ tif = TIFFOpen(filename, "r");
+
+ if (!tif) {
+ fprintf(stderr, "Failed to open %s for reading\n", filename);
+ return 0;
+ }
+
+ TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &Info.tiWidth);
+ TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &Info.tiHeight);
+ TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &Info.tiBps);
+ TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &Info.tiSf);
+ TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &Info.tiSpp);
+ Info.tiPhoto = 0;
+ TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &Info.tiPhoto);
+ TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &Info.tiPC);
+ w= Info.tiWidth;
+ h= Info.tiHeight;
+
+ if (Info.tiPhoto == 2) {
+ /* -->> -->> -->>
+ RGB color
+ <<-- <<-- <<-- */
+
+ numcomps = 3;
+ color_space = CLRSPC_SRGB;
+ /* initialize image components*/
+ memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
+ for(j = 0; j < numcomps; j++) {
+ cmptparm[j].prec = Info.tiBps;
+ cmptparm[j].bpp = Info.tiBps;
+ cmptparm[j].sgnd = 0;
+ cmptparm[j].dx = subsampling_dx;
+ cmptparm[j].dy = subsampling_dy;
+ cmptparm[j].w = w;
+ cmptparm[j].h = h;
+ }
+ /* create the image*/
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+ if(!image) {
+ TIFFClose(tif);
+ return NULL;
+ }
+
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
+ image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
+
+ buf = _TIFFmalloc(TIFFStripSize(tif));
+ strip_size=0;
+ strip_size=TIFFStripSize(tif);
+ index = 0;
+ /* Read the Image components*/
+ for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+ unsigned char *dat8;
+ int i, ssize;
+ ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size);
+ dat8 = buf;
+
+ if (Info.tiBps==12){
+ for (i=0; icomps[0].data[index] = ( dat8[i+0]<<4 ) |(dat8[i+1]>>4);
+ image->comps[1].data[index] = ((dat8[i+1]& 0x0f)<< 8) | dat8[i+2];
+ image->comps[2].data[index] = ( dat8[i+3]<<4) |(dat8[i+4]>>4);
+ image->comps[0].data[index+1] = ((dat8[i+4]& 0x0f)<< 8) | dat8[i+5];
+ image->comps[1].data[index+1] = ( dat8[i+6] <<4) |(dat8[i+7]>>4);
+ image->comps[2].data[index+1] = ((dat8[i+7]& 0x0f)<< 8) | dat8[i+8];
+ index+=2;
+ }
+ }
+ else if( Info.tiBps==16){
+ for (i=0; icomps[0].data[index] = ( dat8[i+1] << 8 ) | dat8[i+0]; // R
+ image->comps[1].data[index] = ( dat8[i+3] << 8 ) | dat8[i+2]; // G
+ image->comps[2].data[index] = ( dat8[i+5] << 8 ) | dat8[i+4]; // B
+ index++;
+ }
+ }
+ else if ( Info.tiBps==8){
+ for (i=0; icomps[0].data[index] = dat8[i+0]; // R
+ image->comps[1].data[index] = dat8[i+1]; // G
+ image->comps[2].data[index] = dat8[i+2]; // B
+ index++;
+ }
+ }
+ else{
+ fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps);
+ fprintf(stderr,"Aborting\n");
+ return NULL;
+ }
+ }
+
+ _TIFFfree(buf);
+ TIFFClose(tif);
+ }else if(Info.tiPhoto == 1) {
+ /* -->> -->> -->>
+ Black and White
+ <<-- <<-- <<-- */
+
+ numcomps = 1;
+ color_space = CLRSPC_GRAY;
+ /* initialize image components*/
+ memset(&cmptparm[0], 0, sizeof(opj_image_cmptparm_t));
+ cmptparm[0].prec = Info.tiBps;
+ cmptparm[0].bpp = Info.tiBps;
+ cmptparm[0].sgnd = 0;
+ cmptparm[0].dx = subsampling_dx;
+ cmptparm[0].dy = subsampling_dy;
+ cmptparm[0].w = w;
+ cmptparm[0].h = h;
+
+ /* create the image*/
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+ if(!image) {
+ TIFFClose(tif);
+ return NULL;
+ }
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
+ image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
+
+ buf = _TIFFmalloc(TIFFStripSize(tif));
+ strip_size = 0;
+ strip_size = TIFFStripSize(tif);
+ index = 0;
+ /* Read the Image components*/
+ for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+ unsigned char *dat8;
+ int i, ssize;
+ ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size);
+ dat8 = buf;
+
+ if (Info.tiBps==12){
+ for (i=0; icomps[0].data[index] = ( dat8[i+0]<<4 ) |(dat8[i+1]>>4) ;
+ image->comps[0].data[index] = ((dat8[i+1]& 0x0f)<< 8) | dat8[i+2];
+ index+=2;
+ }
+ }
+ else if( Info.tiBps==16){
+ for (i=0; icomps[0].data[index] = ( dat8[i+1] << 8 ) | dat8[i+0];
+ index++;
+ }
+ }
+ else if ( Info.tiBps==8){
+ for (i=0; icomps[0].data[index] = dat8[i+0];
+ index++;
+ }
+ }
+ else{
+ fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps);
+ fprintf(stderr,"Aborting\n");
+ return NULL;
+ }
+ }
+
+ _TIFFfree(buf);
+ TIFFClose(tif);
+ }else{
+ fprintf(stderr,"False color format. Only RGB & Grayscale has been implemented\n");
+ fprintf(stderr,"Aborting\n");
+ return NULL;
+ }
+ return image;
+}
diff --git a/codec/convert.h b/codec/convert.h
index 95c3b357..68aed4b3 100644
--- a/codec/convert.h
+++ b/codec/convert.h
@@ -35,6 +35,9 @@ opj_image_t* bmptoimage(const char *filename, opj_cparameters_t *parameters);
int imagetobmp(opj_image_t *image, const char *outfile);
+/* TIFF to image conversion*/
+opj_image_t* tiftoimage(const char *filename, opj_cparameters_t *parameters);
+int imagetotif(opj_image_t *image, const char *outfile);
/**
Load a single image component encoded in PGX file format
@param filename Name of the PGX file to load
diff --git a/codec/image_to_j2k.c b/codec/image_to_j2k.c
index 71e3dd6a..28208c5c 100644
--- a/codec/image_to_j2k.c
+++ b/codec/image_to_j2k.c
@@ -52,6 +52,7 @@
#define PGX_DFMT 11
#define BMP_DFMT 12
#define YUV_DFMT 13
+#define TIF_DFMT 14
/* ----------------------------------------------------------------------- */
@@ -356,10 +357,10 @@ int load_images(dircnt_t *dirptr, char *imgdirpath){
int get_file_format(char *filename) {
unsigned int i;
static const char *extension[] = {
- "pgx", "pnm", "pgm", "ppm", "bmp", "j2k", "jp2"
+ "pgx", "pnm", "pgm", "ppm", "bmp","tif", "j2k", "jp2"
};
static const int format[] = {
- PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, J2K_CFMT, JP2_CFMT
+ PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT,TIF_DFMT, J2K_CFMT, JP2_CFMT
};
char * ext = strrchr(filename, '.');
if (ext == NULL)
@@ -443,11 +444,12 @@ int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters,i
case PGX_DFMT:
case PXM_DFMT:
case BMP_DFMT:
+ case TIF_DFMT:
break;
default:
fprintf(stderr,
"!! Unrecognized format for infile : %s "
- "[accept only *.pnm, *.pgm, *.ppm, *.pgx or *.bmp] !!\n\n",
+ "[accept only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp or *.tif] !!\n\n",
infile);
return 1;
}
@@ -1145,8 +1147,8 @@ int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters,i
}
/* check for possible errors */
- if(img_fol->set_imgdir==1){
- if(!(parameters->infile[0]==0)){
+ if(img_fol->set_imgdir == 1){
+ if(!(parameters->infile[0] == 0)){
fprintf(stderr, "Error: options -ImgDir and -i cannot be used together !!\n");
return 1;
}
@@ -1234,7 +1236,6 @@ int main(int argc, char **argv) {
opj_image_t *image = NULL;
int i,num_images;
int imageno;
- char process_file = 1;
dircnt_t *dirptr;
/*
@@ -1319,7 +1320,9 @@ int main(int argc, char **argv) {
break;
case BMP_DFMT:
break;
-
+ case TIF_DFMT:
+ break;
+
default:
fprintf(stderr,"skipping file...\n");
continue;
@@ -1332,15 +1335,15 @@ int main(int argc, char **argv) {
case PGX_DFMT:
image = pgxtoimage(parameters.infile, ¶meters);
if (!image) {
- fprintf(stderr, " unable to load pgx file\n");
- return 1;
+ fprintf(stderr, "Unable to load pgx file\n");
+ return 1;
}
break;
case PXM_DFMT:
image = pnmtoimage(parameters.infile, ¶meters);
if (!image) {
- fprintf(stderr, " not a pnm file\n");
+ fprintf(stderr, "Unable to load pnm file\n");
return 1;
}
break;
@@ -1348,11 +1351,19 @@ int main(int argc, char **argv) {
case BMP_DFMT:
image = bmptoimage(parameters.infile, ¶meters);
if (!image) {
- fprintf(stderr, " not a bmp file\n");
+ fprintf(stderr, "Unable to load bmp file\n");
return 1;
}
break;
- }
+
+ case TIF_DFMT:
+ image = tiftoimage(parameters.infile, ¶meters);
+ if (!image) {
+ fprintf(stderr, "Unable to load tiff file\n");
+ return 1;
+ }
+ break;
+ }
/* encode the destination image */
/* ---------------------------- */
diff --git a/codec/j2k_to_image.c b/codec/j2k_to_image.c
index 91651de9..223f44ee 100644
--- a/codec/j2k_to_image.c
+++ b/codec/j2k_to_image.c
@@ -52,6 +52,7 @@
#define PGX_DFMT 11
#define BMP_DFMT 12
#define YUV_DFMT 13
+#define TIF_DFMT 14
/* ----------------------------------------------------------------------- */
@@ -179,8 +180,8 @@ int load_images(dircnt_t *dirptr, char *imgdirpath){
int get_file_format(char *filename) {
unsigned int i;
- static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp", "j2k", "jp2", "jpt" };
- static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT };
+ static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp","tif", "j2k", "jp2", "jpt" };
+ static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT };
char * ext = strrchr(filename, '.');
if (ext == NULL)
return -1;
@@ -200,7 +201,7 @@ char get_next_file(int imageno,dircnt_t *dirptr,img_fol_t *img_fol, opj_dparamet
char image_filename[OPJ_PATH_LEN], infilename[OPJ_PATH_LEN],outfilename[OPJ_PATH_LEN],temp_ofname[OPJ_PATH_LEN];
strcpy(image_filename,dirptr->filename[imageno]);
- fprintf(stderr,"Imageno=%d %s\n",imageno,image_filename);
+ fprintf(stderr,"File Number %d \"%s\"\n",imageno,image_filename);
parameters->decod_format = get_file_format(image_filename);
if (parameters->decod_format == -1)
return 1;
@@ -271,6 +272,7 @@ int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters,i
case PGX_DFMT:
case PXM_DFMT:
case BMP_DFMT:
+ case TIF_DFMT:
break;
default:
fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx or *.bmp]!! \n", outfile);
@@ -299,6 +301,9 @@ int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters,i
case BMP_DFMT:
img_fol->out_format = "bmp";
break;
+ case TIF_DFMT:
+ img_fol->out_format = "tif";
+ break;
default:
fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx or *.bmp]!! \n");
return 1;
@@ -484,7 +489,6 @@ int main(int argc, char **argv) {
int num_images;
int i,imageno;
dircnt_t *dirptr;
- char process_file = 1;
opj_dinfo_t* dinfo = NULL; /* handle to a decompressor */
opj_cio_t *cio = NULL;
@@ -657,7 +661,7 @@ int main(int argc, char **argv) {
break;
default:
- fprintf(stderr, "False input image format skipping file..\n");
+ fprintf(stderr, "skipping file..\n");
continue;
}
@@ -667,26 +671,50 @@ int main(int argc, char **argv) {
/* create output image */
/* ------------------- */
- switch (parameters.cod_format) {
+ switch (parameters.cod_format) {
case PXM_DFMT: /* PNM PGM PPM */
- imagetopnm(image, parameters.outfile);
+ if (imagetopnm(image, parameters.outfile)) {
+ fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
+ }
+ else {
+ fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ }
break;
case PGX_DFMT: /* PGX */
- imagetopgx(image, parameters.outfile);
+ if(imagetopgx(image, parameters.outfile)){
+ fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
+ }
+ else {
+ fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ }
break;
case BMP_DFMT: /* BMP */
- imagetobmp(image, parameters.outfile);
+ if(imagetobmp(image, parameters.outfile)){
+ fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
+ }
+ else {
+ fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ }
break;
- }
- /* free remaining structures */
- if(dinfo) {
- opj_destroy_decompress(dinfo);
+ case TIF_DFMT: /* TIFF */
+ if(imagetotif(image, parameters.outfile)){
+ fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
}
- /* free image data structure */
- opj_image_destroy(image);
+ else {
+ fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ }
+ break;
+ }
+
+ /* free remaining structures */
+ if(dinfo) {
+ opj_destroy_decompress(dinfo);
+ }
+ /* free image data structure */
+ opj_image_destroy(image);
}
return 0;
diff --git a/libopenjpeg/openjpeg.h b/libopenjpeg/openjpeg.h
index 6b529138..ceb5df2c 100644
--- a/libopenjpeg/openjpeg.h
+++ b/libopenjpeg/openjpeg.h
@@ -277,7 +277,7 @@ typedef struct opj_cparameters {
int subsampling_dx;
/** subsampling value for dy */
int subsampling_dy;
- /** input file format 0: PGX, 1: PxM, 2: BMP */
+ /** input file format 0: PGX, 1: PxM, 2: BMP 3:TIF*/
int decod_format;
/** output file format 0: J2K, 1: JP2, 2: JPT */
int cod_format;
diff --git a/libs/libtiff/Tiffcomp.h b/libs/libtiff/Tiffcomp.h
new file mode 100644
index 00000000..516e6384
--- /dev/null
+++ b/libs/libtiff/Tiffcomp.h
@@ -0,0 +1,214 @@
+/* $Header: /usr/people/sam/tiff/libtiff/RCS/tiffcomp.h,v 1.49 1996/04/29 21:56:21 sam Rel $ */
+
+/*
+ * Copyright (c) 1990-1996 Sam Leffler
+ * Copyright (c) 1991-1996 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _COMPAT_
+#define _COMPAT_
+/*
+ * This file contains a hodgepodge of definitions and
+ * declarations that are needed to provide compatibility
+ * between the native system and the base implementation
+ * that the library assumes.
+ *
+ * NB: This file is a mess.
+ */
+
+/*
+ * Setup basic type definitions and function declaratations.
+ */
+
+/*
+ * Simplify Acorn RISC OS identifier (to avoid confusion with Acorn RISC iX
+ * and with defunct Unix Risc OS)
+ * No need to specify __arm - hey, Acorn might port the OS, no problem here!
+ */
+#ifdef __acornriscos
+#undef __acornriscos
+#endif
+#if defined(__acorn) && defined(__riscos)
+#define __acornriscos
+#endif
+
+#if defined(__MWERKS__) || defined(THINK_C)
+#include
+#include
+#endif
+
+#include
+
+#if defined(__PPCC__) || defined(__SC__) || defined(__MRC__)
+#include
+#elif !defined(__MWERKS__) && !defined(THINK_C) && !defined(__acornriscos) && !defined(applec)
+#include
+#endif
+
+#if defined(VMS)
+#include
+#include
+#elif !defined(__acornriscos)
+#include
+#endif
+
+/*
+ * This maze of checks controls defines or not the
+ * target system has BSD-style typdedefs declared in
+ * an include file and/or whether or not to include
+ * to get the SEEK_* definitions. Some
+ * additional includes are also done to pull in the
+ * appropriate definitions we're looking for.
+ */
+#if defined(__MWERKS__) || defined(THINK_C) || defined(__PPCC__) || defined(__SC__) || defined(__MRC__)
+#include
+#define BSDTYPES
+#define HAVE_UNISTD_H 0
+#elif defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows)
+#define BSDTYPES
+#elif defined(OS2_16) || defined(OS2_32)
+#define BSDTYPES
+#elif defined(__acornriscos)
+#include
+#define BSDTYPES
+#define HAVE_UNISTD_H 0
+#elif defined(VMS)
+#define HAVE_UNISTD_H 0
+#else
+#define HAVE_UNISTD_H 1
+#endif
+
+/*
+ * The library uses the ANSI C/POSIX SEEK_*
+ * definitions that should be defined in unistd.h
+ * (except on system where they are in stdio.h and
+ * there is no unistd.h).
+ */
+#if !defined(SEEK_SET) && HAVE_UNISTD_H
+#include
+#endif
+
+/*
+ * The library uses memset, memcpy, and memcmp.
+ * ANSI C and System V define these in string.h.
+ */
+#include
+
+/*
+ * The BSD typedefs are used throughout the library.
+ * If your system doesn't have them in ,
+ * then define BSDTYPES in your Makefile.
+ */
+#if defined(BSDTYPES)
+typedef unsigned char u_char;
+typedef unsigned short u_short;
+typedef unsigned int u_int;
+typedef unsigned long u_long;
+#endif
+
+/*
+ * dblparam_t is the type that a double precision
+ * floating point value will have on the parameter
+ * stack (when coerced by the compiler).
+ */
+/* Note: on MacPowerPC "extended" is undefined. So only use it for 68K-Macs */
+#if defined(__SC__) || defined(THINK_C)
+typedef extended dblparam_t;
+#else
+typedef double dblparam_t;
+#endif
+
+/*
+ * If your compiler supports inline functions, then
+ * set INLINE appropriately to get the known hotspots
+ * in the library expanded inline.
+ */
+#if defined(__GNUC__)
+#if defined(__STRICT_ANSI__)
+#define INLINE __inline__
+#else
+#define INLINE inline
+#endif
+#else /* !__GNUC__ */
+#define INLINE
+#endif
+
+/*
+ * GLOBALDATA is a macro that is used to define global variables
+ * private to the library. We use this indirection to hide
+ * brain-damage in VAXC (and GCC) under VAX/VMS. In these
+ * environments the macro places the variable in a non-shareable
+ * program section, which ought to be done by default (sigh!)
+ *
+ * Apparently DEC are aware of the problem as this behaviour is the
+ * default under VMS on AXP.
+ *
+ * The GNU C variant is untested.
+ */
+#if defined(VAX) && defined(VMS)
+#if defined(VAXC)
+#define GLOBALDATA(TYPE,NAME) extern noshare TYPE NAME
+#endif
+#if defined(__GNUC__)
+#define GLOBALDATA(TYPE,NAME) extern TYPE NAME \
+ asm("_$$PsectAttributes_NOSHR$$" #NAME)
+#endif
+#else /* !VAX/VMS */
+#define GLOBALDATA(TYPE,NAME) extern TYPE NAME
+#endif
+
+#if defined(__acornriscos)
+/*
+ * osfcn.h is part of C++Lib on Acorn C/C++, and as such can't be used
+ * on C alone. For that reason, the relevant functions are
+ * implemented in tif_acorn.c, and the elements from the header
+ * file are included here.
+ */
+#if defined(__cplusplus)
+#include
+#else
+#define O_RDONLY 0
+#define O_WRONLY 1
+#define O_RDWR 2
+#define O_APPEND 8
+#define O_CREAT 0x200
+#define O_TRUNC 0x400
+typedef long off_t;
+extern int open(const char *name, int flags, int mode);
+extern int close(int fd);
+extern int write(int fd, const char *buf, int nbytes);
+extern int read(int fd, char *buf, int nbytes);
+extern off_t lseek(int fd, off_t offset, int whence);
+extern int creat(const char *path, int mode);
+#endif /* __cplusplus */
+#endif /* __acornriscos */
+
+/* Bit and byte order, the default is MSB to LSB */
+#ifdef VMS
+#undef HOST_FILLORDER
+#undef HOST_BIGENDIAN
+#define HOST_FILLORDER FILLORDER_LSB2MSB
+#define HOST_BIGENDIAN 0
+#endif
+
+
+#endif /* _COMPAT_ */
diff --git a/libs/libtiff/Tiffconf.h b/libs/libtiff/Tiffconf.h
new file mode 100644
index 00000000..c1215507
--- /dev/null
+++ b/libs/libtiff/Tiffconf.h
@@ -0,0 +1,131 @@
+/* $Header: /usr/people/sam/tiff/libtiff/RCS/tiffconf.h,v 1.13 1996/04/05 17:36:53 sam Rel $ */
+/*
+ * Copyright (c) 1988-1996 Sam Leffler
+ * Copyright (c) 1991-1996 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _TIFFCONF_
+#define _TIFFCONF_
+/*
+ * Library Configuration Definitions.
+ *
+ * This file defines the default configuration for the library.
+ * If the target system does not have make or a way to specify
+ * #defines on the command line, this file can be edited to
+ * configure the library. Otherwise, one can override portability
+ * and configuration-related definitions from a Makefile or command
+ * line by defining FEATURE_SUPPORT and COMPRESSION_SUPPORT (see below).
+ */
+
+/*
+ * General portability-related defines:
+ *
+ * HAVE_IEEEFP define as 0 or 1 according to the floating point
+ * format suported by the machine
+ * BSDTYPES define this if your system does NOT define the
+ * usual 4BSD typedefs u_int et. al.
+ * HAVE_MMAP enable support for memory mapping read-only files;
+ * this is typically deduced by the configure script
+ * HOST_FILLORDER native cpu bit order: one of FILLORDER_MSB2LSB
+ * or FILLODER_LSB2MSB; this is typically set by the
+ * configure script
+ * HOST_BIGENDIAN native cpu byte order: 1 if big-endian (Motorola)
+ * or 0 if little-endian (Intel); this may be used
+ * in codecs to optimize code
+ */
+#ifndef HAVE_IEEEFP
+#define HAVE_IEEEFP 1
+#endif
+#ifndef HOST_FILLORDER
+#define HOST_FILLORDER FILLORDER_MSB2LSB
+#endif
+#ifndef HOST_BIGENDIAN
+#define HOST_BIGENDIAN 1
+#endif
+
+#ifndef FEATURE_SUPPORT
+/*
+ * Feature support definitions:
+ *
+ * COLORIMETRY_SUPPORT enable support for 6.0 colorimetry tags
+ * YCBCR_SUPPORT enable support for 6.0 YCbCr tags
+ * CMYK_SUPPORT enable support for 6.0 CMYK tags
+ */
+#define COLORIMETRY_SUPPORT
+#define YCBCR_SUPPORT
+#define CMYK_SUPPORT
+#endif /* FEATURE_SUPPORT */
+
+#ifndef COMPRESSION_SUPPORT
+/*
+ * Compression support defines:
+ *
+ * CCITT_SUPPORT enable support for CCITT Group 3 & 4 algorithms
+ * PACKBITS_SUPPORT enable support for Macintosh PackBits algorithm
+ * LZW_SUPPORT enable support for LZW algorithm
+ * THUNDER_SUPPORT enable support for ThunderScan 4-bit RLE algorithm
+ * NEXT_SUPPORT enable support for NeXT 2-bit RLE algorithm
+ * OJPEG_SUPPORT enable support for 6.0-style JPEG DCT algorithms
+ * (no builtin support, only a codec hook)
+ * JPEG_SUPPORT enable support for post-6.0-style JPEG DCT algorithms
+ * (requires freely available IJG software, see tif_jpeg.c)
+ * ZIP_SUPPORT enable support for Deflate algorithm
+ * (requires freely available zlib software, see tif_zip.c)
+ * PIXARLOG_SUPPORT enable support for Pixar log-format algorithm
+ */
+/* doesn't work with Windows makefile??? */
+#if 0
+#define CCITT_SUPPORT
+#endif
+#define PACKBITS_SUPPORT
+#define LZW_SUPPORT
+#define THUNDER_SUPPORT
+#define NEXT_SUPPORT
+#endif /* COMPRESSION_SUPPORT */
+
+/*
+ * If JPEG compression is enabled then we must also include
+ * support for the colorimetry and YCbCr-related tags.
+ */
+#ifdef JPEG_SUPPORT
+#ifndef YCBCR_SUPPORT
+#define YCBCR_SUPPORT
+#endif
+#ifndef COLORIMETRY_SUPPORT
+#define COLORIMETRY_SUPPORT
+#endif
+#endif /* JPEG_SUPPORT */
+
+/*
+ * ``Orthogonal Features''
+ *
+ * STRIPCHOP_SUPPORT automatically convert single-strip uncompressed images
+ * to mutiple strips of ~8Kb (for reducing memory use)
+ * SUBIFD_SUPPORT enable support for SubIFD tag (thumbnails and such)
+ */
+#ifndef STRIPCHOP_SUPPORT
+#define STRIPCHOP_SUPPORT 1 /* enable strip chopping */
+#endif
+#ifndef SUBIFD_SUPPORT
+#define SUBIFD_SUPPORT 1 /* enable SubIFD tag (330) support */
+#endif
+#endif /* _TIFFCONF_ */
diff --git a/libs/libtiff/Tiffiop.h b/libs/libtiff/Tiffiop.h
new file mode 100644
index 00000000..e4ffc59b
--- /dev/null
+++ b/libs/libtiff/Tiffiop.h
@@ -0,0 +1,287 @@
+/* $Header: /usr/people/sam/tiff/libtiff/RCS/tiffiop.h,v 1.80 1996/04/05 17:36:53 sam Rel $ */
+
+/*
+ * Copyright (c) 1988-1996 Sam Leffler
+ * Copyright (c) 1991-1996 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _TIFFIOP_
+#define _TIFFIOP_
+/*
+ * ``Library-private'' definitions.
+ */
+/*
+ * UNIX systems should run the configure script to generate
+ * a port.h file that reflects the system capabilities.
+ * Doing this obviates all the dreck done in tiffcomp.h.
+ */
+#if defined(unix) || defined(__unix)
+#include "port.h"
+#include "tiffconf.h"
+#else
+#include "tiffconf.h"
+#include "tiffcomp.h"
+#endif
+#include "tiffio.h"
+#include "tif_dir.h"
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
+/*
+ * Typedefs for ``method pointers'' used internally.
+ */
+typedef unsigned char tidataval_t; /* internal image data value type */
+typedef tidataval_t* tidata_t; /* reference to internal image data */
+
+typedef void (*TIFFVoidMethod)(TIFF*);
+typedef int (*TIFFBoolMethod)(TIFF*);
+typedef int (*TIFFPreMethod)(TIFF*, tsample_t);
+typedef int (*TIFFCodeMethod)(TIFF*, tidata_t, tsize_t, tsample_t);
+typedef int (*TIFFSeekMethod)(TIFF*, uint32);
+typedef void (*TIFFPostMethod)(TIFF*, tidata_t, tsize_t);
+typedef int (*TIFFVSetMethod)(TIFF*, ttag_t, va_list);
+typedef int (*TIFFVGetMethod)(TIFF*, ttag_t, va_list);
+typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long);
+typedef uint32 (*TIFFStripMethod)(TIFF*, uint32);
+typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*);
+
+struct tiff {
+ char* tif_name; /* name of open file */
+ int tif_fd; /* open file descriptor */
+ int tif_mode; /* open mode (O_*) */
+ uint32 tif_flags;
+#define TIFF_FILLORDER 0x0003 /* natural bit fill order for machine */
+#define TIFF_DIRTYHEADER 0x0004 /* header must be written on close */
+#define TIFF_DIRTYDIRECT 0x0008 /* current directory must be written */
+#define TIFF_BUFFERSETUP 0x0010 /* data buffers setup */
+#define TIFF_CODERSETUP 0x0020 /* encoder/decoder setup done */
+#define TIFF_BEENWRITING 0x0040 /* written 1+ scanlines to file */
+#define TIFF_SWAB 0x0080 /* byte swap file information */
+#define TIFF_NOBITREV 0x0100 /* inhibit bit reversal logic */
+#define TIFF_MYBUFFER 0x0200 /* my raw data buffer; free on close */
+#define TIFF_ISTILED 0x0400 /* file is tile, not strip- based */
+#define TIFF_MAPPED 0x0800 /* file is mapped into memory */
+#define TIFF_POSTENCODE 0x1000 /* need call to postencode routine */
+#define TIFF_INSUBIFD 0x2000 /* currently writing a subifd */
+#define TIFF_UPSAMPLED 0x4000 /* library is doing data up-sampling */
+#define TIFF_STRIPCHOP 0x8000 /* enable strip chopping support */
+ toff_t tif_diroff; /* file offset of current directory */
+ toff_t tif_nextdiroff; /* file offset of following directory */
+ TIFFDirectory tif_dir; /* internal rep of current directory */
+ TIFFHeader tif_header; /* file's header block */
+ tidata_t tif_clientdir; /* client TIFF directory */
+ const int* tif_typeshift; /* data type shift counts */
+ const long* tif_typemask; /* data type masks */
+ uint32 tif_row; /* current scanline */
+ tdir_t tif_curdir; /* current directory (index) */
+ tstrip_t tif_curstrip; /* current strip for read/write */
+ toff_t tif_curoff; /* current offset for read/write */
+ toff_t tif_dataoff; /* current offset for writing dir */
+#if SUBIFD_SUPPORT
+ uint16 tif_nsubifd; /* remaining subifds to write */
+ toff_t tif_subifdoff; /* offset for patching SubIFD link */
+#endif
+/* tiling support */
+ uint32 tif_col; /* current column (offset by row too) */
+ ttile_t tif_curtile; /* current tile for read/write */
+ tsize_t tif_tilesize; /* # of bytes in a tile */
+/* compression scheme hooks */
+ TIFFBoolMethod tif_setupdecode;/* called once before predecode */
+ TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */
+ TIFFBoolMethod tif_setupencode;/* called once before preencode */
+ TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */
+ TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */
+ TIFFCodeMethod tif_decoderow; /* scanline decoding routine */
+ TIFFCodeMethod tif_encoderow; /* scanline encoding routine */
+ TIFFCodeMethod tif_decodestrip;/* strip decoding routine */
+ TIFFCodeMethod tif_encodestrip;/* strip encoding routine */
+ TIFFCodeMethod tif_decodetile; /* tile decoding routine */
+ TIFFCodeMethod tif_encodetile; /* tile encoding routine */
+ TIFFVoidMethod tif_close; /* cleanup-on-close routine */
+ TIFFSeekMethod tif_seek; /* position within a strip routine */
+ TIFFVoidMethod tif_cleanup; /* cleanup state routine */
+ TIFFStripMethod tif_defstripsize;/* calculate/constrain strip size */
+ TIFFTileMethod tif_deftilesize;/* calculate/constrain tile size */
+ tidata_t tif_data; /* compression scheme private data */
+/* input/output buffering */
+ tsize_t tif_scanlinesize;/* # of bytes in a scanline */
+ tsize_t tif_scanlineskew;/* scanline skew for reading strips */
+ tidata_t tif_rawdata; /* raw data buffer */
+ tsize_t tif_rawdatasize;/* # of bytes in raw data buffer */
+ tidata_t tif_rawcp; /* current spot in raw buffer */
+ tsize_t tif_rawcc; /* bytes unread from raw buffer */
+/* memory-mapped file support */
+ tidata_t tif_base; /* base of mapped file */
+#ifdef __WIN32__
+ void* pv_map_handle; /* WIN32 file mapping handle;
+ * must be contiguous with tif_base
+ * since map & unmap only get tif_base
+ * and assume 4 byte offset to
+ * pv_map_handle. */
+#endif
+ toff_t tif_size; /* size of mapped file region (bytes) */
+ TIFFMapFileProc tif_mapproc; /* map file method */
+ TIFFUnmapFileProc tif_unmapproc;/* unmap file method */
+/* input/output callback methods */
+ thandle_t tif_clientdata; /* callback parameter */
+ TIFFReadWriteProc tif_readproc; /* read method */
+ TIFFReadWriteProc tif_writeproc;/* write method */
+ TIFFSeekProc tif_seekproc; /* lseek method */
+ TIFFCloseProc tif_closeproc; /* close method */
+ TIFFSizeProc tif_sizeproc; /* filesize method */
+/* post-decoding support */
+ TIFFPostMethod tif_postdecode; /* post decoding routine */
+/* tag support */
+ TIFFFieldInfo** tif_fieldinfo; /* sorted table of registered tags */
+ int tif_nfields; /* # entries in registered tag table */
+ TIFFVSetMethod tif_vsetfield; /* tag set routine */
+ TIFFVGetMethod tif_vgetfield; /* tag get routine */
+ TIFFPrintMethod tif_printdir; /* directory print routine */
+};
+
+#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */
+
+#define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0)
+#define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0)
+#define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0)
+#define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)
+#define TIFFReadFile(tif, buf, size) \
+ ((*(tif)->tif_readproc)((tif)->tif_clientdata,buf,size))
+#define TIFFWriteFile(tif, buf, size) \
+ ((*(tif)->tif_writeproc)((tif)->tif_clientdata,buf,size))
+#define TIFFSeekFile(tif, off, whence) \
+ ((*(tif)->tif_seekproc)((tif)->tif_clientdata,(toff_t)(off),whence))
+#define TIFFCloseFile(tif) \
+ ((*(tif)->tif_closeproc)((tif)->tif_clientdata))
+#define TIFFGetFileSize(tif) \
+ ((*(tif)->tif_sizeproc)((tif)->tif_clientdata))
+#define TIFFMapFileContents(tif, paddr, psize) \
+ ((*(tif)->tif_mapproc)((tif)->tif_clientdata,paddr,psize))
+#ifdef __WIN32__
+#define TIFFUnmapFileContents(tif, addr, dummy) \
+ ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,addr,\
+ (toff_t)(tif)->pv_map_handle))
+#else
+#define TIFFUnmapFileContents(tif, addr, size) \
+ ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,addr,size))
+#endif
+
+/*
+ * Default Read/Seek/Write definitions.
+ */
+#ifndef ReadOK
+#define ReadOK(tif, buf, size) \
+ (TIFFReadFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size)
+#endif
+#ifndef SeekOK
+#define SeekOK(tif, off) \
+ (TIFFSeekFile(tif, (toff_t) off, SEEK_SET) == (toff_t) off)
+#endif
+#ifndef WriteOK
+#define WriteOK(tif, buf, size) \
+ (TIFFWriteFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size)
+#endif
+
+/* NB: the uint32 casts are to silence certain ANSI-C compilers */
+#define TIFFhowmany(x, y) ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y)))
+#define TIFFroundup(x, y) (TIFFhowmany(x,y)*((uint32)(y)))
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+extern int _TIFFgetMode(const char*, const char*);
+extern int _TIFFNoRowEncode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoStripEncode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoTileEncode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoRowDecode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoStripDecode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoTileDecode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern void _TIFFNoPostDecode(TIFF*, tidata_t, tsize_t);
+extern int _TIFFNoSeek(TIFF*, uint32);
+extern void _TIFFSwab16BitData(TIFF*, tidata_t, tsize_t);
+extern void _TIFFSwab32BitData(TIFF*, tidata_t, tsize_t);
+extern void _TIFFSwab64BitData(TIFF*, tidata_t, tsize_t);
+extern int TIFFFlushData1(TIFF*);
+extern void TIFFFreeDirectory(TIFF*);
+extern int TIFFDefaultDirectory(TIFF*);
+extern int TIFFSetCompressionScheme(TIFF*, int);
+extern uint32 _TIFFDefaultStripSize(TIFF*, uint32);
+extern void _TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
+
+extern void _TIFFsetByteArray(void**, void*, long);
+extern void _TIFFsetString(char**, char*);
+extern void _TIFFsetShortArray(uint16**, uint16*, long);
+extern void _TIFFsetLongArray(uint32**, uint32*, long);
+extern void _TIFFsetFloatArray(float**, float*, long);
+extern void _TIFFsetDoubleArray(double**, double*, long);
+
+extern void _TIFFprintAscii(FILE*, const char*);
+extern void _TIFFprintAsciiTag(FILE*, const char*, const char*);
+
+GLOBALDATA(TIFFErrorHandler,_TIFFwarningHandler);
+GLOBALDATA(TIFFErrorHandler,_TIFFerrorHandler);
+
+extern int TIFFInitDumpMode(TIFF*, int);
+#ifdef PACKBITS_SUPPORT
+extern int TIFFInitPackBits(TIFF*, int);
+#endif
+#ifdef CCITT_SUPPORT
+extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int);
+extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int);
+#endif
+#ifdef THUNDER_SUPPORT
+extern int TIFFInitThunderScan(TIFF*, int);
+#endif
+#ifdef NEXT_SUPPORT
+extern int TIFFInitNeXT(TIFF*, int);
+#endif
+#ifdef LZW_SUPPORT
+extern int TIFFInitLZW(TIFF*, int);
+#endif
+#ifdef OJPEG_SUPPORT
+extern int TIFFInitOJPEG(TIFF*, int);
+#endif
+#ifdef JPEG_SUPPORT
+extern int TIFFInitJPEG(TIFF*, int);
+#endif
+#ifdef JBIG_SUPPORT
+extern int TIFFInitJBIG(TIFF*, int);
+#endif
+#ifdef ZIP_SUPPORT
+extern int TIFFInitZIP(TIFF*, int);
+#endif
+#ifdef PIXARLOG_SUPPORT
+extern int TIFFInitPixarLog(TIFF*, int);
+#endif
+#ifdef VMS
+extern const TIFFCodec _TIFFBuiltinCODECS[];
+#else
+extern TIFFCodec _TIFFBuiltinCODECS[];
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+#endif /* _TIFFIOP_ */
diff --git a/libs/libtiff/Version.h b/libs/libtiff/Version.h
new file mode 100644
index 00000000..11b9435c
--- /dev/null
+++ b/libs/libtiff/Version.h
@@ -0,0 +1 @@
+#define VERSION "LIBTIFF, Version 3.4beta024\nCopyright (c) 1988-1995 Sam Leffler\nCopyright (c) 1991-1995 Silicon Graphics, Inc."
diff --git a/libs/libtiff/libtiff.lib b/libs/libtiff/libtiff.lib
new file mode 100644
index 0000000000000000000000000000000000000000..224b1e8d250857da3770d8cb59973660a69dd94a
GIT binary patch
literal 229770
zcmd443w%`7)i=B*GnouYAOQjd2s%JO?gSDb5Y#|I0ELhX5ETV-nUG*eVlu-;5uqVK
zIHG7R*48R*ZEI^=e5|!~onU6x;Xve(yuw?1{NcHOJ3l8n*YA#ph|c%-)CENP_pf8*8TJHu
z#=rE%fAbEJXVLrQ*)&4^w#+5ZIesydpC|cc&ZU@~4EOK)wb<
zUiN4DLcfZ)$a`%)c^k$>|5hzsSWr+KZDwA+)Y?U8BR$xXCs&hr*_zDdcptp}eWSwtkJ}gQ!v$X|BmH50_6->Xe4U
zWlgo=(30wE5yLz}m>a3C4mH6#0&gwqy!y(9s!&yFxT&@q^3vKmXm2r>ly8V;1SyKC
zw6eUuuD0Ik&gNk4x(S3yQ(nyvg_nn#nrj=(2+pesRbFe0$ZJ^F7zu}LLVl>aJW>~C
zLTT;wroV-ebrqqeCDlxAR&p6FY1m-%xLqu_jS}K+#V)L`4KJ;U)K?)U5l$u8)W{Jv
zrdy%d{%M_rY${b!-W*o4IL>Td9g7YMCy{Mj?hx+O*FolVLuAga4VQ%0FDARrlAQLmAzqVv{Sbm2XjfNysArX
zWMbFM=%8})D9@Pa&Wa|*&7z~wcBJe@;lhTZhURd7h;zSL);J7PrXyCkG&yLQQ@hfp
zXIV53eo<3xeK^0iDO4G5Xwn6_k%@DfD{E^_VK!lDxfz>9O`)n&n-J=7!ePn#Ind&8s(kwkS|viLoe4E;k9BceF61OA{*C
z+^pQJjEszI{G5-=wz?v{Y=Q2wIg6O*g%=A_P#tZTHRT54)X!fO4T
zdTHFH-_))eXt!AzQ!2XJN~|I>y73GF>MpqKqM$ZZS5;OUu8|xpiCa)xUnS&)_0`Bd
zLR%baS`&&UN+F3Rs*JL<0rHk^YP5RbexO*oDCPr86sDN1#M&
ze1xM&$RQ$MrOqPM!ch!Ju&xw`6WEtVD!Q^DAoDhcL;QtMvX}AK@Y*QGuEizLV&oJBTiLis;zCh@Kecp_j&c=+Hb5y}!sqBQ|-c;6@M4-QuC=C&$p-
z%oxhZiJ`ZykD)%lkD()HW9ZM9dFibRFV$b`rEv{j?mkg0^`@Z|hj%J4^_ME<{^Sw!
zU`obc4D18=rGe(76iT8#lt}(4Hy%o$cv?NQnbXrT+NwpBJ*@
zK(+s3p$&7eZ%P;D8GxVtH$-$CMEu86-G7?SK6)e^4EZk}e;$#od{2dG0JQ7}sD5ei
zH4Rdw3`93wqd(+!2JG5~?9$HdzQ(huy79p^o=N>8je+i~PLmqdsx+xw$m|xW<7?;a
zANAbGh^ljX{`!lJqmNV2ZGDagle?X(3$;oMZE_T4jwz7s&o2zFu1D7oG*hhh3LD%_
z8F#~t?Ys0A{+remE8NYus=JPbrg0jX&3wBB*-f)Ex(Ul(Sq-KCy4BS~FNfRh-Sz~c
zK9|h*MLGv|15bj%Z9Z4mmF2m5u1x5uzo108K5&W@-HS3izIKV|`I8Bos33yUwSfrY
zf70ZDv+jD?OpYEJh$`5Q-d%KeP8ttOs@=Uhlj!K&eW9KpXU=nU$-6WxINr~zJ=H^D
zceJxul(P>lW_N|=8kIQ57)n%13TM~c>Ljy2s#X%JJ9BDM6q7r93X|fHFHKbQMrd8@
zZYS9et57AM{f904ZaUNdkG1~(i@t}%&VM*IAZ|nF92H!nzdyqJpNtXO!wP1@*(TV%
zv?kX;V)Os6{R;`%hNxjb-8*$QfiKLqYcYh~Gbrk;HtVi}VJsq+-9+FlyVsNPfV}FwxD%KJckOgabY{eo}VN7Bj
zdTutMwrK-@IV?h@*%K6kNZn9dpE;F{&`xWVr9C#^Q!+B9PoEwPPM@A(^;{NtV(F^-
zvDy6-iT0yM!Ox^B9!XmtQYNAzAg^kJe#a++k4Nh4rvT^#4^b0-{KVjwOBwBxn%s=N
zK;L2VFdskQ%bgSsZ44`;z+f!Vt>8Q0Ct4UF8cSDDkcw7MstQ#^)}*s{@+5=jO3WzL
zCMa`XycSUM+=*3cXu7VpVpb$lTQvzt@ZS;_Eu5R@;##sOzi`gtd8I)mooH0^tYBVw
zeSJeX*ue7;vtTg^zeTkb{22@C4_7o@wa{5g8-9ND#L#0DjGamI(8y0uTyBKZ1ID8C
z#2VPqxxw(|tw7C7lD9*}?ID!QNNokP5$i
zE$^o9$xkO!v&>_y?eHZn>F%d48~Ierp$QJ(_wLPXcNzD(O?&skWnkO8yP$OG@-m5v
zqRi70V&izrp+L(gosq;K_yY&*nE9mW&sU&VWwF%ghXANGXPP9Khm^xLy2J-G&%
zjEc)Tf7f!hGaUOQy2W(5!xQ$l{Kj*-BZl8GdzPjrFE0U0Yx^}fUZ^}2U&YIoLy4K~
zt5#Zm-JE_mJSi?K(zdppP6FufD_T2O#gH?iOa@8oGUH;_c6sL?Ob#1c-iOY<-^gwI-ma7n@#;>0w^r5%C-q}es{=IFV6W&`8Ie6uq+7e@&
z+MS=CYW!yRapT3^pBSGR9o~N&d@Z@!=s5Ux%m)t`&$Ybn{on_jzT=;1ZEwT-rXL~}
zuF>hp*_d@sEHgHzCvN+Qz1h;&ILNNQV;o`E_d!eJMMV&COwjRHYFwS3%nBz$*Ujmv
zt*^9gPEXlVb4OKVANT?CUI3P@o#E*%&vs_EzyISiFOL6cIr3D%IB1+PJ~jiL*)G90
zJ_gtOKd$~Jr~S(6w)vgL&FRSy0I9xWkzm{*1QxWgWKVu#qRMGtNEUl!NC+@`vxK!7
z?2%;FlIpf4ovtjmYTF^!yJPSF!}=$mkN$lS()sxLF#yFM4aQOdvjrOlm?78*z%hbd
z1Q---0wDAHDGLy#9|K|KfJ20~4Uk>=i4$a;U_S$#D%fuTxjIjw3p|8jGUgi%tW;>1
z0mF&|(D-vzEZ7|u-(A4?6PiLl1I8gpp_hSSoDeQv1GYl2v%snai$PlP*Vj*pz^Vir
z15DXYwQTc%)r;+Az?75^y%>rV+HibdZUvS?(}CS0v^l_d;LuNtfZZ%uDKJB@hk<=f
zu-Abpx2J*KB{Z}Y=&OPy0#k1L15<7}T&Oefi=#^c1C$3CFEOq{6GK5zP(bjDk<=mj
zj^LbTL_ZgtQK1Jgo&xpa#I+
z6b9@=8vv7NGhi~^1lX5$0rsOkfc;pet^({s7#~JR*8nEddceMPJzxrL
z0USU#0}i6w0aK+3Li9c09(n>Wh7JRI=`%ndjY6u&(k#F@x&kmD4Hcp_z&*4XFot#l
zdg&K{K6(={mOchVc|@Lw6TR~VG8Y`-!O9$YV3z0KnG;PuaSS{iKW;o~vzDXZ(ey{b
zI|4sMXbN740rhCUk+vBuL{m&N3}UV|&5$qdRo;~FhBu;9c
zRKbFP{EL%Xi|ea6$_3=|5GQp8`xr;70doaw1myZJPW<80fLsR1c{Psq16Bz3ARy<{
zIBEyvTpCA50XfgbN$L8MV5b1NF^cp;q;O+2jwV&}@Q8Xo??jq=xR;_j7?mbHmwO|U@BUQZA?l{*#B-+S-1CM#YXzx?=+HZdOVOyuLo
z9S}}6^>Dqf9`Mkl3a**e!;(WB0g$Vnq4Jtkr+9SOLNqC)C@kG}RbjePFK1T=%0g%E
z?66LEO#e}(&B`dpH|y;6u#a4}%As=*Z}l{31T=-Ox@c(W%$nOe
zk2hV}uNI(<{_0i?n@<6^bdxeMf
zVQH+-Cg_u4F+FTy&iGNTv_8{Jo=kc7tj~90Z|gI|lB|(ufIKKXtPe}$x~>)aaEVvX
z?=|9zALUBxlVkFzchCAf0X|zF>26rk8TlK2?f9wu!_w06yAAr};!U)wx;b3V)rdUK
z_-O~lmYk;;Xs*0_*5?hEs{+%N{W=Zwl<;u;urx1z-+(@fy9VFP%Rvb7s~Qu)w6^3N@RHhq-6FC^{6%FRf24
zGvc{MpbkYpnB1W_0$Fw(ZWV4P;5PA5;o(rQH2(Sy?WMj@inGk657Vx7QM86ij@EFy
za!hOFtu^FuyES}MeAljan6B*CR@k2s9@dbhaXobrG~_R*dJLC7OuM%W<)%o`
zzV9~WHORYXo%ncUg@@CE
zrM2L9FMMwkChfc8(Y`-u3b;-2m|;(X$?f}>UA`YNUD>Zx_`cut-Rog#+}ivIzU$aU
z`v*Mg;hezFTo;AwjjW8!X+hYqg;#14P_oi23J_Y+ovX}Li${l4>7zsXJUhknb%8pb
zxsGy&bQO$3k#h8sa63T=zONP@{uZz_4(V9VF7l{QWXJ1d$pBg3L-ot0#*
z^UESpgPwK15REZg=hw6Yd2fIcY8_rTQ%}+JFqdMWKT;RUy>!Z@m+DdA+}xSDGu8a0
zb0vp!9jeSp@T_@JQvnZjMS`HItiV`oXj9ragPPxV+I}T2{YKn|0V!u+&JnsWuOM^C}hPD>L>mDJOxP
zU)NAkUbm>B@>z*ab4V)*DgPw4
znQL8W9p?2+-(je9ZYhw>2Hb@*=LW2Gs4C?aV^trou5H*jCwIzp$WR`I!gDIawd+G=
zSRL4~Ar~vy);G)SVl_#BOrlYXl1`eQC34IH>D@PaGDyz?P07g0Qg*B3c^0S)vp~Ne
zibkKAnWJZcMuYyUE2G1}vp`X^J6!$5NKv+#yPMr!_yXt^*Z0MsDkXT-?2da@
z=_M4W2X+6?6bX6l&aM%YkK(r-V|hyv27Y){GA+c|A>K#j9GPo~40r0w4Trw*IX6*glBOKB6n
zoU=`7Jn?~fuN0%O$XGsRPkwwSM7`H0T*hJGk1+r4g2bc)%Zu(0w(U!U2ayYxckaWY
zOT=81^n%31U|T`rGT0Z1J*G(4egZhbx(3^`A>Lu`|o4j!$mI~|N2>{-t7@MX>7IR8v*{ML
zX*rZUr%f=GY-$2Ua!+EJ~|IGpUBTlFD*rCX}%}(Rh06TmNiZo~XqbXUklv
zXF0(%7SA9B%Q)VuRE!~peTc3OP?idX^MmE0ATjgVYNPP7)+3Rjrw@4|1C4!mb9_q*
zmRKdl*uhlHrwuc1;j}F(UZyhy@}@0rA6puS4+}eDn%eepCSdiVm_`3eUl%sWMkuRJPpCwI?_f
z$apA$exqXrrtMZJ1+DPFc_KScZ2!~%l0q671VshF!y
zTiaO-o)U}4;!fu5ZAF->9+OoDPwOT?w%{G@P!@itqTaZ$$ncjH3A+F@ASq^TrK-@u
z(RtRERhWg^rtQhuNIqTXWF9k)8;8$)U=*Y$9eB|w%uoe8^VpvJKniN^6#SN^uxjUBn1zv|M1IVaY~7$*>u
zX{F1!I;jI)QYjKEk>|?owtHmvW7Wp;%UX}>>@GP~XKFK!0#pkWR8po>iL<*c
zPl|~nw@a0`%6QtDev;oMyAPIxSnH}*VpVS6(T)h?iR7FkO=(EE;_g!pyns@580#08f4G5@73i=c@s`;
z*^<>69%mGcK@lHmsdMszmMuk{;eLvqVAK7X?b0mZ?}z#bE3G5Rna^_ODlD`<&hiC4
z__vrcQOr1A)^-mETTIZ-IDuLCA0GiFJgN2X;c;basZ{KMEK^PjQde$A5H2#dB%V3Uoy2fI9aX+fw$LlBm({umOw&@0Wj
zg=5uw7%MZ9_e^MIjh3m*ZR|S&gK>OWi7V!l!O5#EcCc+Y50Q2$%h{9obM1UBnF5xk
zr!QMedwh?ps6^=*gA{4Ir5!FsU#@Mg>@WsGK+w#ehj*|oKPMQNal&j;9!vQ>9dhG~{@%Y!hjrLyAAeNO;`q@2UynPx-EU(z-9Q6{AN
zGhN0Y9G25IuhGA4AInG52UWze{IVkOa9EW1k>@2|;#Gus|FFmReN%40`@*V~Z2_H4
z)hE)-pHE5)qH{}iW_zizG7)9yveu5s04!gMB&+(jOxH+((}#U4!l;G$>YbkktSTE{1gOSh+hij0)_-z2gn^U
zKQ#jm6xzdpJh1Dh$1U2Yz<9toMW)u3y!#=)UTB5LvgrE3#d2WEkFCH)2yF*2CHX7B
z6yG<1DYq{GQ@VTuLtn#1-ebV77mTN_6GTcZ#%7e{Nx;SlEen{Eyb_q=s|Kbd-wRAh
z`7}>EMdIReV3!MaE3j39
zeGk}5!QKGIlL0C8zJ>Kc5U&>6APc(&SdGvQ08=iW1hxh=KXm|ub6`h+DGf#=S;9ga
z4~%oDpE7_o0ZXAWVAly&XJKCjru@C%!k!1#C~jW`X2v)&3lA>)X$~+%60ibb%J%EP
zHVbXPW&0h=HW67^rTJ7~D&3?fFT;m^SvMLdxoj=*aAj|a<35sdYbAA4WC73s)OB3?
zSVAgo16(V^%|mDh@S!ql6O^IW;dCD;>2wfq6de)H=KwFFzXFb-Hvz}eKLE$k$AFV4
z-a|B*`T(w#iKpqrwL!K_7tNvq;5o!oHM6M(@M7Wy{?PkR7U=*xh!=nlYv^aH>_^kbnM031vmfI)f{
za5%jt^w$AL(n-K{ia}j6iuwVLrh$O7Xb|8@B&&7m`)o2htoE|k#s;P
z4+;K=;2GlMyTD`U6kr0q2N+L-P=_T*4M;Q(xStjR=Fnw;0lES(o*DoXXuZ%k0QRHX
z0Q=Kdgt8BC2t5RtMlS+hKyLwFNM`_p^a)@NeF`|7Iswxu1-0QQ8Vxv_#sTKgc)$rX
z6L2Es08XN%LSF`$LDhg$XsuAL1Ewn>@9-twBy=V$xA}t2&O{IWov=p!}tp)5yO@Jx17jPi`5O5GZ1eiuY
z0YoYT4yBic(jt;i0r!#@--cM?Js1JH6tEBF0wz!yU~jrcD7%Hf9(WApmDdM(`$1(*
zdHtGDaD<%Au_#o(CR{TjxS=LgAB;5PY=K~NsIk1MJRAx()|J;|AL^*8SwVH=L$D!&
z-3!&hCKfOuxUPI-a8#8gcTH2nhM;Up307)e_bt?d&pCpv23#muBj8nnZ3X0vpcZ^`uSG5R)}T+H)!n
zBy$iB{4gJuqj)$EXdb;Jfhp`lEhC-AMm!@0>Lm$TFbR*ftc>-xUEM3(8aU@lW7(zW
zC?NODfBo@eKhs=jDM7!Vz0eg0{RKFXEW
zhc|NYvrM4Y2hFJ{eM;h-`fwlB{cvA&weSQ{E?63WC2|L-dROrtw_NEIe8)u*ou_5c
zr=TjGg_1RsK8&Jd)4NfWY4mUuWh!lVQ!;1L6;YII%7~&&Hy4d^XmyTK;nFeo7+mnP
zTA+@xAuzd9a1D9@b_((`O80XXlt$s<7+VcX{*Jzi7zjqAkO7}Vi!tCBUN{)_s9GfLit3a(G
zx60fa{!w~e+SL-%m2%7QZcttm9?lyqjkOFz!`*Ccl`qAkLPxmod;-xL&-DBoA2
zB_jGrKB?~F`wu}`Ej;WyOXCpS#~DZ-ojQs~`_8$*estKG=ni{>%l9Uit9F=HMK4Ko
zElD!hCPwo}!``u+>0E5)N~m+OI2KWzi%qY;Iv0;~?bf;Y^tvyT$6B|g>E?P&ecZ2W
z9izqU^h|MdIqX$pN-M5-gv8xoW$b$LnEM1?VRyukLx^5vCP#hJS_=wkcS75WtBCiN)XuloWR!#q=d6SkVZ?_!W=MaVtq-=;)Xjnm~BCrom{l;DZI9
z2&nA%8_SQWEJotgqpJ|+QoUVv-(&yNOrJ_|{6+eoakrNrQ9e53n|=3sIL0}aFM0hv
z^ION9{H@@Jw;soM@X3)LIR`+6knPOnqKtx1*R9H=>(&usYYswKy#@A}e|B4(V@N0x
zMY`Xt96S49TqAouK|tnqKO7PzCkUOnN5b)(s3YCd(Cybamk?e1vp;SPCuxevo8oeH
zF-%elxl~1;7sLfJdht5bOh%GZX!uArjAWfx*_$yv+fnv>v>fY?+n|*U^gxsD%HG2+
zePQTk{c!`xe~jYGrLL#TaQrQVe^=sHiJu2C)m<57KHf~O`x`*NKpDk~V~(W>LGxh4
zVCJN(icq*bV`^4>UPI%irrI?%;oz9cvB4=bv$H2onK^SBkI)7e;eb*cW8Z~m<`k2s
zwyqX~cER~g<&8D9mCX}^3+pQ<$xbon`7W$17fU||;rZbzKxH}fz+4a8_f%wcvVQR*
zdv$o+Zxg@)rtc&wonmSwvd;dbRXj7XZM9;Km^X*dj0u*^)L4D;>NF8RB~
zSz!8l-eo81yR{#o_iY&ycm}KV3=sa^8pVKkwWEtZK
z=vd(S9Jo(s9`mv>c;-yf0W4e1Jhp135K_*3kaXbJ*Q|iyAeKMDf#Md&Hn;Gm39q1I
zWNAD*QtPJVupS?O%8do-IWIO1FsRsEMRfvU;3b_nJ;_)w1}uqeUu*=Fy?goJ
zS?o)U{Rg}y;1tqjPkweMN9d`O
zF`1_&JtDoaaI4ywQgC-#}sEB7SMG4isZvv0l0uFjqP1<<_v5!@hVyXrQ>LbMID^9M$v_7H$o;%=FyoKg?$-6X%tw)qSwoY6
zS$>|Kodwuij-lxzqnt^ybvjvA()2ag0r8rhRM|>6MApirQ3oi)=xM+qbQ&;?J{1aA
z=x9qq2`?o9#?o*=KaB(&OuPUuK$8LEX%1ilus1CMOrmnYWNBp#rYhk5X(QkO
z+6OpLc0moMyMU+CJ%EGFmNk#P$IuS|z4RkMAMu*RIN}Y*0U5>ZMZW+ZPwjvS^fX|i
ztgT5V58|?~tf%QmDZo=`0APRO1*0hv%NXGT?jt@<$WJ(I9Flo^Xn+<2;xHY+cv=b=
zD=YQlB}MS*6bi4?i>Lj7DfE57RN{kdhS0l!7tjZQ7t)7-!{}3?Bp^jEq(neJB?+D>
zu{s=hjHDO7AcD^k`jx=FvVt=KQJpKb&LYCv2n8UjHSj=UPB$GO{;pE6ek?pdrtfOP-D2}9318<
zfKlE05b5Cz7-^zZLO*$O&*Kc3(VE$MJ6m*!Xmo@2BR;vI@%Jk_c3NyvT{rHma`JMc
zL={J8i;m@}7Trar0F_j_MaLDA@K`N6mSwxjH(jY$*N)m&Sa1{Pfwyk|mf~T^RT}3d
z)wyIJIm1;Tw{fC#2gcsW2(=MXZVvG?{^E~H6~+UbS<^Em3kZ*z7Mz|zxnOWmrcIaZ
zq$un*oq;?-XdrT?O%=1^vEoNG)bX>(a>Iy@AMSFw%@+i(Fu<^K+5Uq_I)UfLV*uNTN${XxiAHV2VwWHG%m_nXr^<~
zvVB)P+IO9~xC?BDopYA>W#x@Bk*r;DYry?*(yg|9XK7q<@X|9b&bIH0N6Y!D*zux2
z;W5L`12=BplTjLkB4PiT>B@dp098C3c9zD~)T8j7s}S3Fx11-%j+bx>kLf%6^n>2e18bO&k;7A?uti;{W-Byi<<42@9H}*qO^T~-gITZT7ec>
zzURTjz8;0|>e0R{9_{;4Z7pw|=ewr+Z7$z=s>Oc34pe$@|88*B+}X~3emzL)7!YOD
zb>O<=)-!g(_V$2mmuntGgJ`Ps9o3y^=QZv!HGA3&HSnVLee<}>#yDQ9s-Eupj<4D=
zp|EboT{2)3BbnA_?rz+r9nm}$eD9;4`YtMrepsd1T_2O>{TWHy2fFbCXEN^MtX7%M
zRoVoTht2$)e;<>%wbGq=-xpJ(<*m4u&wbdrq$EYFKGv!FNF0XyR+0*o@%!$B
zg~YyfFft-1u_QHj?4MTKh}$Gngr`g1+#D;fWkqTadQq{_M>_s`U?5d(g~A8|@BE%{
z@)3+Us65D|y&UW=kMF;GJpY|@U(A2$-fI>pR5;Q(K>rljP%-@pa4dd)dINBbV4IQu
zxXI@?ds~eC-J*F>cP459-L>~Ym
z4G{Wqa%|Cf$^t%t76DGC&4BT8sA{Ghsya=2o-^qg&}Y%}fEUX_Q1SFK@Y(dgLV?QG
z><$R>%r)Qm_(=86O%C8}km%&NR(&`&sy-a&k~k{FdTU(J7+Hg&w6viixGqvDh045P
zNL_$7D~Q#&-0qKB|5_Cs!%LipU(9P^$M)2{GQZ-L@DJaxFVMZp{OCvjD~?>Jv2d8x
z%oy8+fBbdM+UCPyPR37ogr;(nrZ~H498q3RJ6`gw{?3^>;y}O%6ZKLMU;o}PacuE-
zUCGl;GG=2rs+)EP8}V?*%x(~x>EM`8V_CMVyM$Wa0c4
zIYGsS&I$P(4C~R2bFLp*jyrb;fF)OrNHRYKCSR
zTGGMpjyK7}XY=y`~x>;EeM11}c)*s_N0TB|5aZlBHwg(&7br3&3xY_w|tJqm;
z*lsI+8^L$hWh>`~tL1pHL?I2ObEl;b=C9^uEFPZ75f6ERhT2Jf+?ue6^`Fy@TW(+Dz2uoANb
z)>uDA)y<)58R3^bF^N%+ov%VGin_
zIm4n$a}A8-PwJG(9}MN6Io-ox{xvK1_~w}7_(=zz#sI#3Uz`cy#WAL6^AT5X7WBhF2a@KR>IPQk%SoA#xPHc=1#~4Q*<%CCKyoU|o
zv5szu+4|x5)N>?r(tDgF(VY*O;gNX7JVvp}k3>_mF;AIODtqQ)QiJDNFu#JS7w0Si
z4~Qh<=a<#cTzjU-YI?4dQ)HZ+tFIK9TURvIk?R90b~^(4r6tvia)HOouIMB=jyaK*
zgOX%^WkSNa9WYJ~rVr4azss|6NeLbO6vNYjXm!;<-Ql8k95|j5r)7^B8He
z`*oQ3iy9X67~-|hURkB%qg>#zbQz#uT8(O&8TWNU4vrKS`VPQ2`Wj$BM)Z5pw}B^`
zBhC*4_tBGpu`*`wmxEH{==Z{ZiO6|Fc>Wg!^gIX$~?PjP&W
z5Zhe9v4Rx=GF^>{bB<7B;v6SEElyCiGJga3`68_*yPe={?I0%bh2?sd>(=9~?>s1i
z1(=m2as
z9k=ge;j8WHTH$sA{zmiadgVJy<1jx0-#M4szAGLb_6=gk`)-BD9AfPn_RC$q-)OqB
zUrT`&S-!J0&Rc(k?<$AryrFos?>kKaY6?JyokQskJI_AaVdq$NKWkxZw0vi2T;h2@
zI+sQ}?21SGE<-c0MMIW(dJOx0F5lhld3L!CzXvVfSsK?b@yMvER@7lvJlgkfgNL77
zfj#^F2bb>;2)7e_8HU#^-*aK&e8?w=s7L#*c(m_7)zC0#F$RW0ESvq_vK|h9n0WJ|=O_HI?%lMzuYPs*6PrJc`O@5{MtrN{Fa2&WIX3m7ruXA_
zU-sO%AFO?6$k(p=b{%eQqiI&7>dK|KoytR{r^t
zC%1g=**53k@NbsC-uJfR7pMHsb?^0RTlnnQ@7KOP_^vBop843Ok78TrJw56>p*IJ7
zW!dkh{WS8g-g_4Rdg71P{e9RsuKCl&zqs);Z%bas$ZuEvwf~n(f1CM}<_{8#%YQZg
zfoo3={rZYma(;fpCviLHAHL{&YyLLq&aywu_}PXtNw+R}Ve)~7e_nX+s{g(8mp65i
zC&ufG^~VKz#U~{8?vs?HZgucMDJ9$@;XP3L#
zj`lP+*xB9-`v4;`yNbNK!MVV*s|YJ=xMgn~S@>v@}=c|p1pV%
zWO*($-`dP=0De%33rY7ev^h;#v!&Q`i-jN9eRD21(yZb1LM~7XH8;=JsG&I}k
za1`bHcQi$OFJorc!%`o_PlcVOaT(kXK^b`4VOKob_iMyXovCO0-Zkc*2cI2dm8L8E
zwH4@5{FLvykHTk5sX9ov(-n{Qz19@q?xS!m?T&dL!fgBAWV*6ncLGfo9*%jI)*ruD
z;k&z!qIk6LPn!aA<*j4BYq=Qd^8K*s%6>fnG{f>e7bdRFPQZ8d=&&mu?fb8^wY;_O
zUBmvm%lDUEu6UGIbwe8F)`qdKacOyl-m=(*z!$cc)-+(>u{dGlq6QqrW0~ggi8V{A
zqj*fJn>D{7VtK@ZOeQB8TPeDz;M{r1Yh?ItjPvcYOqqhFX^|45UL*4mGIYgYVX*-GJ{+{3A%kf+aj8zakfzz>;YCcAy%-$!&fTEW
z#dphXHo4343gt=;?_OWjWqJb(X!v;b^+h>yc5Aq=-MU5uq`|+O
zC)1#Cv)e))=gJm2XTxd63*(QtuL@xMHgTvA3*KAG0Zhb+$*Pr)20kVUg2s+^gb+(}
zQgV(r4Mvbl-9eTs0akP@$T^NFmjX<)K-Jb`m^@itWS+;4#YX86hV33BEz9p@ZDK0AEsz$~XyDOA_E*+VH(%wv$Bf=Foi-r?xsjD3#R_;G9ZP(?}}Q>^s8Y
z^6hSIziCi0nB2iqJlL7h@^NR_pL6ua7~?5S$EY1KMfQQ=DRw``bsBacskN2m?>NK|
zr`a3#Jcux@C7e)PR%)Fjj6;Y=sr)GC9;Yvh+CF2QF)s%V)6;*nk$@c!1
z{p<)w?R$@u6>DoQBKG<0?$ekhc5xK*D>vb6^JOa2SeogxmF0Zx048R(^AImj3*kWd
zKScP{ZFrZoeLJY;3EcgyW4U|j;^s4BcOM5xoy%?b?#I#GdlFM~o?CyBF>smM;Ur0W
z0qNY<+cFv#3{U-vg17(-FqC5^^v(jubbeg#ic0`8Q}PS>}W^UK(P7BfPY(Gpb$7K1xY-fgiS57ZV^zGf{qV46(02gw*=3lKA2$K
zl8rFwg1wBlHBN{s+Np?n$(T~0Q7X$yoYg|o_M62okt4UfsAK=f^jN!`tA?0h><~c%
zi&agn%Q%@{?s%p&;VRUVHrZhuMp9f#c+oE5D_9EBmz5b?GH`(lYEfPlVyw*K6(Mc6aPGi8
zD+kZ~E9t;*&3l~q5-Po+6&J!B#0F!Rs((;-zL=LUxHOdplT+Jk?3R%#U_3zCvN7O^
z^f%O{57sAxHv$*Q-cR$Ek{83nTAzIk0mCgN^1|j}C$}VrJ2v+2jW%;DJNa}6-!oBw
zo~op-Gl>(8j=RP`_2OBsKawr!_6Njt?}d9l^uJs8Er0QPpE`IpraKv?`#8Ags{(p(
zAII*!-MR0D;NOa0ij2&ln*?khAdl7f>25$CwMZczZ{QIlKOM7Zyt*|PrWD!bxlOQZ
zK~wU0_v&cS)b3R!SIP73il;aNiahsBqUcF0VjjRU6K@`>ZwLR)9iZU#0(q&x|X$C3PW$g)lFsd=~*
znhq>qZ22tlc)@akDaj4MwuzLl0m~CxzA-`Z-DmN20NW^hf3$4>3QUC~8KV?)#dZiV
zC2uw`6+_nmTOzibfbm>@3bg=RCK!+ID88e>%0Tne?|~`(_!RL5;alj}e09K9311U1
z#djw#&J}*T4_HWC@VVbSHsq&R42USc0$`lo{ItlT?FF_*XndZx;`=Eu6}$fc#$!c(
z;DE6Iz6@YoDfwv{utx=(1x(2+
z1@<%HQ?mm++U%2ct$nfHoM$F@d_P{!x=4^45)x&7dmkAOO_rM)`kG_jJH)LD4@-}u
z?*Wdd`vH52uJQB)@ZR(?U?2LE*!~$XS$2T;rL(~MVf2N^R^m{uQ;27I##1WbKnen0
zDC2SCX$tTWlmj?g)^CibV&G%sHd68L!8AAnp0JeIawAn^%t{plva6xs$jfbJAJ
zmuVv2>)N^fRK>q^lCA+?d(r3UEXn>a`PXX*h*?>c7CSYGG0~{bbx(CV)2}6l*
zNJu5V`gjQ41vr#)#h0G~_Yhv>-2i+twE#|`uK;Gz1Ax=$e*p7{??%X`V}kz{aJJls
za4~%-lz#zUN^!AV+w%S{p6p0N{Q=xZw*bb{?SL`FcOb+{eTH}w+n)>N7l3~H
z6<~l~1H>K?zyb6oU;@1h*qh!5>?7;OlW90=tiCi6upeat4lplkp9efvZbk6Z6~L3}
zO29Z;1K5i;0mjR%2+6bscp~it>`iw7_Mv@%I1wK(S!x@#rPM21JAHHl^ms}{Rgysc
z0f$oxU~kF*>`SG9{pc#8uK*lCn*fK>HvrS_2ld^>6a(0sMgk6|X@EoM57mgb^#{RZouC3HNZafL%<|@6cD!!0H)BN0SCx!1_S9N
z@WJ#hU@E;Y_%`t|7N1xzB>-aA4`3e}3W&2O00T4zuouk&jHe>N1iBKiH#GtFkuL_cw?Ceg=$$>c?i-H%29_Lna%Vgh&!T?Xi-MS$w|
zgIHP#JU|-(d(rhmzX33TwhDfi=)Yg!K~TK(2S6V^AQTU3c`pqG^wCd+GDj#Ygu;X^
zLS=g};`v|G3ce%m&S{9@ZIm?=&L7L;t$Udx;PZ_NC)RI}KF
z1PcO=6pZKOCJ2@b$n~~5eS%GDrR^fY8UeYr6-QeEdA3fSH6IdeKOmP`b=EwWhd62n
z+$I>$wQ&l>(QAOW3U&&Ra{-Dq0=HkVWMG^Fu(Jvnr+ge?OVq3&A866dofL9&0NeL`
zZ3VMH248K#7gcmCr3x&{pPqSGjN(~XzrMV#R^M+>u?ZJwR5nEF!xPLK59B@r@SgL=
z12;4C^883ommho~SsWi$zNLgI<|QT7O%3aUU9KrX
z1nC=1gtytcsKn%F{p_nstl7^>v_~r|gQJ5}#`0AkTrYIB%RGnO4AX8>HP7*>=W{fU
z*La+A6#a{=atXhZu9j?cvw!gl)1Nt;Unn(EynOiOn#i&CE^GzO4#gDV
zP-|r1ySeg&`*Xr$g?*LB>FR3JmHql1(AB~N-#r(>#O;7Z{nQsu@tssJKug0JGbFdT
zHB@qR>TEJyajCF1M1)0Y*b7<34%eN+?F65|kSsi`Axq=$;zQ7Iny_(@|nZ(`V4tR=AjZaaUKSHSlS;obMX^=^x%`@B@~9eB
zYpBA6)UhuLv4)n-O&`-{3JNi|zxTlCJepu5?b|u@Zh(
z3)K2>JJuaze6W)pV?|x``8p`M!oxAf(zxw@AM^>~ZR(SqL5I5Nqg-iyZZsvY6<1mx
zEWwG==SMDm_H@zbhoC%Y>f`mWH10dR4}DahSK=}H_4;N6Hvg(ry8#L~EbbHxBP9;xDRM#c;|eZisO
z%;|FbrdvZLM{Bsx^lP(A!(lMFQ+akTr-r}nqT%zPm=9oB{A|O?1TJDu_5_X&jFm
zp`q%VYTp%)_T2-0`PnT{`)kJARr)vUZhZx)MhMK8NpHE#Fz%xAA)%zH@I3-;0WB
zc`F_*XOJm}OR)V->FWDPkVGE|^|&s+_XZ_HcsT4Vtr)*g;kz0KkkpxxDR-vY`DezA
zsT6=%CnZD9kaXuLC0Xk{$@Kl}tg`hTM9`yRY@17Gz8}l|q=B;6)H%k((l~J0Xu|Cm
zMjc~{NBe$>Dd)S2$85>4OLuzR=JGwai|>;`*>CyI(z5Zp1in8Yk{RS#t~mF0f0xUQ
znORiljzioDv)ZEQP$<82DDq9o4~kzp*Kr8kp*Zde#R5woaR$IAN4#c*f~C#IuLz;|
zsb-PUWM$w`a8Ah1m`=Ma4HadYjQ+aQT}jqD^I0(bJT9#nkRCX!HJ&}#n-XMH#bnXTMfG+w!{tq3iB#oY%(eiz)rGw^ofb9}H8h9SK_(`NS4vNr
zjv(_0k151nJZ-MKww7aOPVI?Pt;Mz&r)TxVXs*YW{h^Ibwe{hslTxN*HMR56C#6iu
zoH9e%*=wymqt(11mz?unYwhUKvb$FTgwjp)Cw#T}K?jU@&9k$Q&-A@0dAH%?F&yQ8
zN{|=5oTMNXt)5iT%%5-T;c_4SZ0+Vml?*WbWE9a~@#BYUqVqpdMV$O!0PAY&C)PGk
z+)z^+4zW1XTv1nEc`chu=FjDUw}vL*jpcQru#9oS92~<|GL9tn>&hF)f+viNf^p?+
zQ>eaj6K)G`W+D1^;VR%)=2hgetQo;E85?JerM!jnf{VtLkEZfB(6ot9_-d%G=G%WWHjb*>7*D}qX{3Tj#)3;XHHKy(7xDODQ>ZFZ8LFDt6l!j$
zi||Fi=4HdO9%NMWx=3BPc4A{W?s2YasEn)&)raA3vbgOU>*^dajNP%9W7$u+`#C6A
z599PP95SW|>NaShKopr&ITl(Ixy2MzgSrmqT+8745xz^>WK=9Jr`&{v+Y&2GU|ll-
zKk;i!q`o$cTcDc9Qn0ahW2mlqa&3KOjo6vyN_5eJ!WSGB2}*c2az0aXQJdlF=7xGL
zmBY!k_hdB-0CEJ3i0|@sjnKBBp=n)tcvcYZ*EiHwv5e;0HT66MS|1Lr!8IxrsgI`M
zB(8b$<^`+k8p`>W=wM?5nAs`LRpAUfilY~P@FxLj$M@Oq6|&C^X02d_^@4
z$fqHUu2*7kJ{)R-t1v`!D7xdHw-Kpph5&=eqaxf0fm~?X7^Ic9yR4i`bI@ox67ro65?
z+)$6{f~H_qZMY_cVjven!%|%kT~%9M9cd0BwcNV#w|hxbRj5gXuWPQD7;czY*IW@#
z0E~ka?M7-JE`80MAw;oJ5oAZsC9Jcu*SSh7UWuZ{dNETa=QxE%>7(4{HQ+*?+R9ou
z;lz@>&iS3)27?Q9Xcr)wU|%P<`XF3Y>u_X0%zF8FnIho*xD%AO*=1NR)ai#)oarw2vySM>|o{1hynpi=d>AL1o
zRbHAW7jdC9OA+f|(y#$#izkLS(#O=|R&tc!5DEY)6f+JN*CPL`^0vIZE+Sck%jIHR
z9p4?jv>OK!U2s#{jU#QRZbnDEIIc!l`HZi$M`>60(#wtZ@zyuUN#&lhGfx$9-D<{T
zFsMwCbrqb$%v{cKfD`wTR~MH{6qxl;aMU!OGa5B5qJJD2W4Jy*JgfSlj6bo#BCb6+
zV@%X}0!3zBIX)A4HJHOel2oEb;{u1gGir?!n(s_
z0DqVzLjZyA_^e>23(ANtnJjz7sO&l}V}RGhQ?GEKqIXk#eZqR25;Uq3zl=;C?Sfl`
zc?6A+P+}PeFFo)9^3cB@%LjPD17m1~$>fP2OAvV35z|rtF#-jQdD!Ha1#A5U3j%VZ
z&M%WZ>gCto&2G*->V)+j8ReH88~oZ@rA5+SdxDf#LoD_P))Z5GBSX1p4_{LY7gM(Vc{3
zmXQ5#Bm}~dm*>~Dyc_saTKdcLYZT)0CiP4QH@U-?@`-Wt8;v6i!=o35(-wyN6}e?6
zpG*^nCll2x)+Hw3Hl6NB4hLVJzft=f?#}1a9l7BFnOIT3Bv);KQZa-SI6Xhj6K-~h
z%xp)3LBF|s7Ie0JP7)pWJbscyd6u
z5;?7CYtr_w;8krL*vqfhzb9>H5yqdk{gsbKcW1@K$6&=w>z5k`?f}ZkJdcc{E$>ix
z>}BB#E(`ZBGWVb9=ubI$p-PXFeayGHmrpY!wmcnkxd@It=m;DFW~@p(eK;7N?Vy@T
zxAQFPh}_jRU#WAiweY~{!@1#w4grX>LgN6Tmk1Aju7cCP{vu~M&Fva%X_?rcV5XKs
zX~v0@FN;Q7aqHBxym95$PhnGS-1#wHu0n+}$&u@!@Bm|{4}L`@h|!RG=4lL!QFyUK
zHJvRN{Kv%xLQ&C%^STjw84K;UAPx}jlTjs*^R5o&A5}1qcN0v`k_BD8+xaSZzp#(F
z;mO9%m*5iR8~-oo2L6QWx?axpaec!?yd8eE915Q92tvztF7`Wb5iM`M8Ly};n2dNq
z^^U~2^KKwfB~C1pIi>cqQA2e!jC?v(%>|1@9AVC>wg@nqh*
zgmQsY^Nr;#VAaMlD#~mxVRMnQvcpE6td>Kmd8mYQj&DA4GOGHN3eOiFZR~svvUR!i
zNx7ux;)oAaAbgpz^9=`UiYmg%T!eEIRT)OX)`-tUx+~q;rw_-3)$V+iz+87D4ys$*
z*XJ7do`5fzf0r*ChyLX}Ez7H9E_1}83T4{7mX5#zW{$jQ%uhRgC^>06lCrxbz>N^!
zh_YFd%QvslZ{JkO@b|VlT%>VJD@ex9cL6!FQ?4j+MlQYs)h#y_de+ZHE1+=C&QoC9
z_9lNu7!&E#u^Y5*%tj{p+Jp_B>
zmq!4{e`5G9G!lx6yQWqOQp=ZfqUq1POZG}`tGFI>2P(EKBX*K^Uqjn*_2=zi!S$4z
zvAy?V=Jq5#`N5Xtnlgk#*Aan}eZI+7i1fx$Y{3C6vu*QtbI(CttBc!4l6D7jXZ5sp95p*=qVye6kj5+-9qbU(Rj;Eo6u%hG(I+Em(W&Qw6(x?3hg>z
zI|SPZjKkt5K7>vA!3$fs9`)1B7VQCGEkfgMIEwFSU|$m2uPoZjz_tmEZ{AUSXMk-L
z+NZ#_2o@8gZ4-fQ7Fs`x##7SQ3+?}~_b%{JRpu?RTwpy2~31>MG^&sz&28KSFO%
z9zWz79`{IM_Kg~GF({T@nk;o~xs4~HysKQE1&R~>G`ZR3eGk++<=yM@T0!+y-X2g_
zD#c4TOt^mmwN`m=ySyyFQFcj_{-BK9si3%Qh50q8)k;luZRdenrMyc)U9Qw}P^^t<
za=9zF0n`fRZ3M;kktSPQ+gm_!4LVJzK4!wDVq>lH9&vfQKrL6^UYGYLP|K9}y36|z
z)KcXg2DM13W1x)BJyM;mZ@ob+R9kL9S^z2}=YgU^6jl~M85cF6*yhsYQcw@7+*(i<
zD{s9kcQdGql=mH%_dQS-D(^l}^ObrKRE<)J;YMS!i2W9fgmnJe*dFh}G?^ICi+prGg@=8HfC~ut0dm5A}-*-TzEAM?!8|jEhr2
zl_@XRJUw%i~pUW0bei<=qO3Z-g|t)8#z`>OAHB
z#^pT?YP9m6cX@AtDpB5lySz?NqmIAmbhSMn)F7p%feI@%50r`D
z)u2vO-X@oKJ1D;Au{9plbxKib=xU{Y2x^m3Pl38$snUgLTztwZBN0o*$iM-h65UQ
zPpvP#w5?@o@6=m+zo7Q1S^ECytM8%{_5Bypw|RdZ^<>Mx!^eTTRrzGyhA=-8L^;ENYorW#jZ^`@C3Ar5
zFxfob4i-8eY3S2Aef!E1(z)fNSuh*@>QMnuR7I_fZEdL3#qz$-Lo&|1~{{rri
zH-R_H+rV$jr@&hz1#h)mB@=j?oC3T<&H&!2+k)?sS)jiw%YgUD6~LXkA^3Z;9rOco
zH}L1O6L`P;2>27Z7x-iO8Sq~DIq(Pad*CnR3E(f~S>Uf^Kk)Z*2>6&@Z~2IP2KrGs
z0{pdZ6mFBu9wNKt9N-gD1bkA?2kw#Cz-RUL;OAr+=%-}`@DFl1aIf%4gcoHa@MU=b
z_^SL8_`2S>`)56T@-Ol+IB&=i;G5DX4QhGPANZE!1OKWUh2NG6(CLAeL`zT6A!klzD8&`rP}%Cn&VCVvKgB%c8f$r0cudO_zuq(9yX|0DUp
zPo)U>nVb(iEK`6-qz3r8TnIcWb-*uWE%2B$0XwAyD8BCleZG5ve&1ujR3A4Ar}01QAK%}Zya#A&jJ?u
zb^wcfcLIxj+}c~>`)}ZRKB@|r`i=p|_pIi8DekQ1rSg)~go1oFaYacsYggUv3OR=-iCI
zUYP>)8VQ_|(bAg4Dba-ukE@bV^0OqFk@{}-%8bx?q?c2y^Dr-`NarVBPN9y+4d5WkDr8D&F1x?Xh<#Tfw~DDHDb&-<{yGrVS695rNs1Py&_zohZq8SS3Y;
za!V3txZIe;L766U3XA31M9%QhQkTRTDVMmMg|%xNB2J}b47IkDVB^bNS4LHvakbCH
zL=M!S*)w_KTu>}|Nu1#lO5ltdJxUIv=Zm|d>i6Cx&T!$#-Xl{2wdEwvNVzeIQz+Y#
zI0eF)gvTFjp<9&1K}r)j*h-a?#2KxJM0oufE)_{K7~LmwMwAF=QXW?$M#$bIPN8nH
z@yOsFMb6l~oRP94iBlw7k~jqtN#tP5<0VO)Vtr?Nd`2Cco+MKsV-h)qqx4RCk1N!%
zp-D2sB|DJ=HS<6cXM}u#x4Orl;e~oEh=)@!T8|F#az@H4iLMHYyVrzWBe)9caO^0J`dONsmJG{5mM>;tgcX3dCj9orf{@O
zOyZ!oN#cxQU6*e6{fk!W=P%lpQa*AbtlFUfmlI4*Z
zQ7Au4ltJIiqo6!8#U*k}5~oKMiVceygOD>DMX
zF#K}13X#cDHpc@@;v>vY6rHU?TyIbrcY7|!Kyg?1BAmGK9uL5N#$5kQ>3jG6oXZuq
znTp?s)E~sh#}I#vzYEVW<8XUqg}3nDgb_#y`phSiI7RY^%UQT^?a~NT-|av&*UZ|s
z;V|tqt^nwGZkYHuxxw!)G`~`GasyFL%8hEBi#V?SBOy2Fv>tzpRE8;~Z=8+XiIf_{
zI#z;~@`{@Z!x<^hxg4jwj6Y6T|Ctb$6GPMUF^%UeH`Rh;+jx2HPH=StBC+ra)!J2k
zY+1OLYUDP}4F{@u?QS}7b`z~xHeuGpNfWTwr*>6@TGaNgAFYk!>X)uq0mh1YQyL2w
zE?m82;nIe63s*0`s*B*<#h2+RAW&*uwqmK-wd34wJd*039^>xWDL^Nwe6wd~4(>;|
zIU6Tq+nM@}_v|Fy>BiY2_w4kyGl@TCQdZ`jyfKIyP>;g444-Mry4l;)h-vb@$onCE
zFp9ujZz)dr40CVKvgJz}F3T-9E`jjt`NqZp)y`e+8<;HCI53dleMtYmH7Y6raOh
zw+T+d8=zkgkA^K-0gqHeo0Xm?vN&bB6wmc*dHwv%dDEwNXE*HprO+bh4jM__m?<_eNnXTL@UO+u
zgz?Yh1vJ;4nsi3;EAWe3R=TY(u<~lbo69a%`mD#dpt{!4*60;jTe+xgZT~Og
zZGQ&FCg)gNCz6;Iwzf|P0sWI$O>S&*UToIT_H;0$eKLAA{HS9?(E~%#6GPD#L(v-=
z=XMGcpK24G&KjsXr8c$NIvWQlXfrmGydb3^Qq=k=*|>$HEP6N)$%r1#YRHVu%IrwD
z<6>={k1#B~Y9cl{D^?S-ZsTF{kI-3c>mrb`tzE$(ZK)nrHdkDis;(AQ1W
zUP#e6kzL3mtQ{Sb_+iY|)+mA~Q1r0BVMOrpzQM;Y
z^tFsj2|hjre^>dUt$zQ@(ZBgYclzJlR(UM=c!~enZSy;uKHV1B^p}M=B|CaJwc!%m
zW$^KFDJ@s0K&2`RKKP+B6|&lck5{DN5=8&=(Z8jF?xYv5QWFjy(Zj2Jki*4{j1YYG
zKil*v9pdW5O;0cYqtiTmYGm-#NWYe=zG&*)*r&N~bB-_NwQV`RakCme@jQ9R{6kHj
zZrVj3cDU)!GU>;22&ZS)SXZZ7uRMRW^v(4b#qUPQe>2*dx*@$Y_c7*f%j7SbS~vEt
zwffikLK~xdQYsq$UTdY*`cnB&YxSx1Wg5y6h}-7Bi3>Y^$r!Xupz)jYBy?G
zcUV`lcrtmucj=z>vupDAM2~5deoZf0s=sJ@fl(S=>l<@rv@K;SqtqAisPESO`kRlsN*7S9i1rHRUW6qZ_H}yg!LDWO@cKJlE;bi
z1M0r)-WKX>RHs8qvn%J}CYG0>q}SBC5Ne~i6k;CkV5rVS-)CAGZl5q$cxV*0JQ2V9
zv@$n+h%ovhrd=awHDqh_skYRO?R3Q8TEqZ1MiuPk2tDaNYIWIH+7?RXWsT{O-U{NIJos}
zc%J_;_C++zg>Pt570{x~VryZW!fz(p6`NG^t7xNVzh*rjd^~_A)coq%I6U5#^KHx4
zXUO`|YUdxLyG>8Akgs<9sqpdxh08+m$0D8=bZJY1Y5JQNa6Jlu7
zBW%jJ>Y%1&Vj=c=XmzGOnzUSPnsiokPT*`b=|BaWbo}XS$^4H|P!F(~(Ys{B9AVfGJX89ozb>L%UWa
zrv=p>#}@4cb^o&NZ7)I1UX`0YXI>3j60%@urIK0LK|w`M&pVa*qX+)01}Eb7h{lU8
zn@sHK0k_1=?ySL1u&l%cF+H#jZ2p|n1H0rSLEOldRXw}1vnmW9anA)FsVdxm
zL9DM;nS)pS=6zf}i#`>IRp!JhOxMF~LU{u4)xQrP$h25y_}%=%;*pFNmYf8mRV)
zBiReA3Aw5kj0~x&nWt*O3loY~JD4CE1s3@+A?gR@Q%E)8ey%*ulq5wY!6rx6|eQ0o3Vg`v#~%N>Sg!#9$~WqtiJ8)RpRX7O2~m;=wqUQa{GLaGbjR
zEvPc(rKUO>SpiT+UyGUwW7U@Hu141@1nL6iO$B8%>23kVcX^uJ4r;1WcY&Iw)J{;C
z;lcKYpp2efJE%*P_XkiHEA>1mY8Zy(Jx~`auLIP4r4G5asXZJG!=9jwUSS_l#%_
z%hkndP%D+9rk}Ch3TlP&EKsaXY5Kjv*tUUpnez64Vhu2dpc~sa!CS68>H#iO>L4g%
zdlIVBRm!6_0jIlZvI-QxDyFG!L4#5e@YXBEuUQ+E`Z=g3rT8_iQ7LK^Y*q@N!&Msy
zy2qfR$_s$nq7=W;{hLz5K;5iVAt)28a!?%9q{%c;Hz`%=+AagNU3n`&@x7C#hnE|-
zt>Ar6c~64csnkAD#`X=zxZ@1R{2g?*UgU7H^hE!aBfWvA$jQJ{hZp#8#&X?p0FEYwEO0ci&I
zlpBE=@^8RQ?en311==sK0#j83tB3SM&ygnQ0@H<8&IDv4u$N2*X2?{fmuRh60NStm
zR;j{+Fnj1X(=_=l=yZ7j7?4B2o_ZNWh8zRkOZ=$%nUV?YBPRg+s_s>moTN104XAgZ
zdk8g?(_}0#L&gI$r5xB>s(^j;yK|N-0UeTCfoJK(4E^Lz&;wL6D_b?QPLf}OGf*A_
z=E!c~AfZn2SrPyamcGC>P
zPss;nND;7?V6!qp91rX*6~Lg>0<&~1fZiOmUv2>Qlv{zl
z?}5GTW0{`-jmrjr0eKhLOWp(a&}$V?$CRU!SV>3!l`1*F9x?=o69Rw%DFvp>6kvv2
z1k9Ahz}~VJ*hf?AOkL5G(LRjUDu114_SH0a#(%TJ#eP=#PCme(s^h;IGkBl3@c{;w
zD$o9#234ACw`
z4X{^D*RLxatEEdBkiC<+Y+$rfi-41r;y7=vQjNeRN-u0Ld1EPL
z7M&jln8lCUM*iZP96w*s{3W*TK11m@r^1o?pfcjsk)nToUn6QCKVS@hpO=d`roT<3
zN*JF`vhc)QF35u`OfCIQxAJ@t63Uj5wP&Gal@ooRl}t#+4K2*|df+
z#pA>o-Xz6&JYo?~=~e2+3zy-cQe_w)`o{MAD|p13Yz)Va#xOoKG4lu{hb35y<4gb8(7ES0*x{7Q!!}Qll7wcMLS$vd`u9>#0_|K0(9&*z~-`FqY
zpXhw1azZyUPUzR#9u(`Z6FU37#L%xrHpFxF+qNt7vk+e;#w}f1(x@`bRr
zY(0<9Y=5BVK@OTA_k7W3n==AO`6Y6Ylvfiuh0xvhaz?W$bB<^HVR%mw)OhQ&iJ_DB
z7j21I`s?I8n!QP>+Xl03pH0hs%XSt2c@tzRIk(mq#(kkXM<_~H1;#85e-
zL>d!0NCo$#d1R0qs}eay=)Jw1(M7|deeZIdQV!c36X$m|9%g@Byp#jrLd^5+oIBl=
zgIbKwvxEe55Kj-O3{!e3p7^G0K}wgX99!kc;zHGhMFF8@8Vo$rM5RKEWU8;V~s1S0hGauRtQF
zM0J-FbHl{h$&EhnmF8+iCpUt4(zLsEeqfq6H#pZzG+bT}t4tWVLEktg8r;u}BecDb
zLUHMsm_BRk9);r4>&rYGv}Nk2dN`=hV-q+~K$1c)XEfBGbYFvU<&?XLkCW2DcAU3r
z#GRD#{Y_VKeUWQzpG`|)=_Q&Ra2i#HDWz}h)$c`0IZiSu9f_99F?~E0Bhhl-N#r0m
zUQ6U4H=ax6Ankj+oY5oTit8qcDK+tNQp&d(&9@buly+_1+`*w~SNR29Qp&ZvER|tO
z=^In~GE#cG`pgO)IC{Ve}>yvjnH?eOig^8
zlrDiEG~ZWrQi|*`>2hoDZ3!vmIzyr<1!t$5Qu@}8KOZW`y(-9*mOvkUOo}(9CFsPt
z3K@@c39jS_C2>YbY7(bVM+IJ2!)1R$Zj?Z4lVdxN3=aQ)!sR%*VdCuM2G><-?pJhj
zqwC1wvYy^@=SoYWVf|UFGGUZEedGLO9&&?Y{rJei$T*=}wm%OU8T(*%c#~8Xk0peD
zdza9cfz#@SPTxxKXCd@o8=viQi;;0czsvUL_eRDJy=zT4oDe$KloAa;NnqNEI5X|^
zjlKD=5xOy26R;D2qc2bCU?%|eCcT`IvdHChucuf7%~u}jZd^HKYC?C?#g(qOamuvo
znB+>0v*Sv27F=g68AlhXe8uur%ciWUy~3!nxjHRVaNwk^n>J%P&K&i~xiUD?v|(++
zDc6YyUndIMhh8sTyap$NE}sLPBE#YFhB)vt&ae+8PjqdLC6|TuI5Zn7Ss2WsX}QN>
zk6X8H@zt|x?PIjfV3+o;A10OvrVEe33&+P3q1{#DQVFh2;EApc&$xDjsYaG)PI-c<
zp4^q^Xc5Y}1>pqqb((%fBZ`fpUznPHsX|S^qv)u{*oE7jrr*PE!P`VeR>E|a+%Wq6
z*YL}u2Xu6X|z=;?XBkV_Ua4vL2NkFH^si0dQs!zvS`o$(wJ1n;PrU9r(e=
zzOc2KJ(mCF7?cI@eKEJ_!=lcn7lPY=0B%PrKL$_0OnEHT(*-RHT$X6TJQgCg4k7q%iuW
zKQat%bF5!78u@#yPpW-e+4nh#q!JhB+tyYJbWEpke!F$Zde*vLo$R%CRrST57?GfHhE^lXV#;1%Sa;z!5e;z_;ltzp!s^#7u>!L)MMz#q@!>2
zsBdH4W9-p7dXQeb`Dh~^HdgGB&1LXya|a&}o`$n{VBIjJ@v38;4TGA4jYl@t4{U5p
zDSDyt$fj+BoyZPyDr@=`>
zO3{bp^|21`LDkdc6g)F;o1O~Zv=lBieI_BlVEV1+Vp^E_FE8|e@(36bQ$9Y7<0CB9
zGopJtm4sD-F&}gBk^I-JQK}=-27x*XDcGfviMo)}^!i4sm}H}phbyaV=Gk`mZh!3w
z`EU4-;j8vL2umZNN+Ar@{cfyPvI;pLU~T+&jrUJj7)`I&1h?OZ0O>DEefwRYgO4}J
zq-mRvHG;l2ZS&tmqj%lh=&{Dg1`6tnA^(~Dwn@;?3Qr3@KB?3CcuLc!8!x05O!ITi
zpNzA1Q4z%YxNScUD%;g|Fy-$*wVsK-<^TInGz0he_rgA>BbN@!tLK>y(}>_u|FL{%
z&fq(J3^uI$`EP)o-Sm3!ruist2EQ<-abFPAgk0Lxdhy1SE$DF}6(^Vzux2}1SJZmp
zZq1Vmckf`YgLwfa4LQIwl_F*-RRBCmsfEB3@fXq$kyt+hH4&bNmD=D^zXf#~cxk%5
z{#2!Yi28eqQrt+vaME;>1(!b3WG{F_mHHznE=#59=bJoGA^974j6p~qN6jCpR62TA
zjQJtQ!)Y*Thb@OATx91fAERgtGU$7{9t0AQGSEHs=#vahnR8^!Qt$&hUG1qy1L4$V
ztx*6~XbkVD)ej?12Kf*Rk-Ujwn&F&L~x6kzzsx*c4W8KMe4ru2y-5k()
z`f2VI;c)U)z11x&&7cR#cYt9%9N~2N9_Ycs;Yq%*V;iQ!({to0&_(hz@B-b;Q6_%^
zJxN{$R_dp@D!o-}w(!&39O(egm5+h*^wV6OZX8)DCm>I8r~wd%8US&q0dS2DxF<^y
z=n5GLoTB%5P1TQe(_}I@(`71frc4K3q_?YIEVDshDz(5<^}vNI^&{RoiGowF$1g?n
zz=a`l7dR1nN%L{g_>cumm3M(XXlc5&-(<-D2+F`M#9V2T+wh@
z9ZqbIEDqP=Byi_aRUCf3OuE1DbgjpG`KP`qAg;FYuJbc9{JyZJ_cFQv)bfuUDa{0Z
zNI|kwe3(QCvzJ3BW=4EYM4JAX)q~IZ2&4JyUX{g+R2g@EO26W+Qnh&Kj>fyHk1|IL
zD}n41OY3j)#E?@I+AxNGA46n;^ZI%gk};-YkPd5jMhnK+k>kukj6Y5)h8O`>NZ-QnASccFf`C=fV%!s`-2i>oHKJnN7^$5{oWqTE
z>|i_`1jbIt<&2=rPCOb8JW~xE{+hHqDK+tNQhI?A(DRAnDP=y=pZFTlL$=SRlz(Nr
zivO$vX=GRy!|=q$MGYC#MRZ-y^bV*|0pW^6YMR%2zCO!PoO>2yA7&OFRmObvz-*Mp
zaGZ1{#_(~KFsDYv)5Thxn6491!IYyV_>}D`{<9fmSY?fEex!I+{@QZOC
zfqk=lp_&-dnqw7XDC5N0`0SJgUtMwI)Vcv+CC2$QcpH!Nr*S8s?#G`_8acgndL7Kw
z?EVMyIA@;8yf-zH5^MCUlV06KXh*2ht^Q)xI_wZDPQs(Ld{<1+iCL09*
zygbM5U-@N$Pguo!L1v+RIfqKEjy}`boY8n>aip;E$ht^Q}FpKXA0(|UgMMX3Z^sBqn(jaoKi-g
z>a>m(wSMyR&z|4hwjUmuy)V`Q%#fi*f2L6{)rcHmY%rqdxWB4%Zf*fYidt3AwvH}w
zD7%VS$KWXsOwXjR`A1rArLEOweP(?gnaBiUChnRv!0GMaoCUS7#h3v_l8^0`0f`)ov|65mFL8oT8({i?A9lYeM#w?we3w|
zJal%(9?QdTtc8oxv8MZoxBd*+J}DC@4e2DdA%IA3c5@oek6j;pyfxbTc=T}ohNYOd
z^M!!P?XCRbf$FoYNtv0A9h0ninbE%;2i<
zSXzsUM0z?EE7iJ{xr4B0#~x#@bl%D=H*tuZfvh({JM!HHUG!89cD_`Z7&-C6oHn>+
zHoS^mm$lG(k{af<*2vn;$7alk6ys;g6kWXtZGMmK&(>siW_(%QB+v-fRGR>rCvi8(
zeT|WmO^QtXT3VO{H=AlLO>OPivn4VVH7ex2ZsDuKLb9{1hRn^+@NE)%j0--^5^KmD
zv)Fnj_So%A)ni-?iYy(ou3@cpD?|PC$v|vgD3Wh7w592X;I*{u1X3;iR@Oem7@F{=
z{69naJ9(7~rR}p(D;8#EwKs8E&wdH^Cfhtx!KPne@nRlw$8L{K>1$0znSZtM1z-e!
zDSlGPCbfsdNlWKi19E{Ij{=*I%)kJoy)hdxqiNtKoy_*ekp0~B6zXV2X5&+h(2`fZ
zcduQfXWUL#FkDdoCBD3&&t<7D!#oF)o-^AHWJLG-z*YN3_8Ufo&$U(~+rBc4J$sk9
zz127-@wp8CrF;D2bDxA~^MF{NhO~1bAq~?kGj$KCPBn)-X?meF-&i62R?QJ_2q)8t
zYN4dbeV~lo1E4tV52^0dxk`N>aXJT7n%oa+m{P+~^>UTs1lPErF6v-)u@ThiN^yx|
zkjhcF)X4n~l#zQL6vt*Ec^On#DNa+F7Mzj^%DCWo%eW{3Wn9bzb-KE^2o#q_LUIi#
zvoz8O%DBA|)L^ysqp#uUE+l7x3M(}hl(C%->TK|^5gXJHrRIV%ODH@$lBTDxFxS(h4!k_2sQqAg4};=&kTg955MvNf`@st+#ZoadpDgwFM7`24WS7i&
zurrg@kcig!1r`9<$aj}`X)WSa)(?2`eywO
z_HWVz`WE>C@K)7xen-!$d{?!d-;;Lm-`6FyJN4Ykd*nTEzNe>Gz9k>2?IGZO;zOYrBd3CXS5LBhPlkbhU$vcouG-GOlyY!>C9{DK>oUrJ$Qsc9DK`M$k!Ik#dV1x1
zatG-5^*rjmvKRC|c?S5r90tB1_@;uB9s2p1XVjm5UU>ZCW#QF0008w3
zSAxxI;PshdOh0&+W*$eWVH~j3ur$)JZaJFdgvD!k%E3BZavN65I#9TQQ0Fe;4eM~5
z8V*J9+F;2I4i+08ui+dTUcw+3U$$atc#U58#^V;u)sEfE@|s}Y^Vmh2iJ7e_VqOU9
zEvVY0X$@1*6
z%<|emrNTh=$!2+t^~m&Cla#6ivJR!oA|Pu}x}E~h`jak=z{N^&kWi=8P9STJ(dlKq
zF*?1hHAbhGb>?{byE-{t3IR1`OK~gbIV+ZRhBGj3!D>aqgp)aB^f)Oz{iZJ`sH23*
zCQ1=9KQ$Ioe9_U(Hi;h=ELR9rM%iZonTj~42v1lT@^HrCiN?ryC#7?mB^Z@)
z*Eq;we9X$xGCsl-DmrT%e50z;zO|SeW_=K<7y3@~aFDnIz66;9EPo_$pn9S2&$z1+
z_{_Jfhcgo2pA$J4;&Iu-mBBI$YB-|j;lSs$E{CaklAy*(SMkUq&nh0RUN8bctz)*1
z%OX6}XH#3Yf}%0?%Bd}E@haoi7VbujyIPC*CYm?#xKm}qs4eu3^=macB=fd%*5izf
z6Z$;clQR8vLT9g<82Tp(p)XQtFZ_)UsHmnMmf?Xt^>-2aB>ZAbY^UAGIH7;bPQ_#+
zW9#>rwhkFL?dj^X8&hyULN{+@Cv+p@__M|KXXe+0o}Cc-)-It3
zzzMsd(>I3xYlLpb08Z#e#tFT}_Q#Zflk;8E&a)fi<$hC_(D~7?zzv}FJ<7wdq81FZ%T3&X+@Cz+4q3Li=yY
zipxAtJV|i%;(C0;&<_>3hMX5&o6jls7mP$djn!<-6Ozu$n*$xb=~t||%m_?08e!eY
z*y?=7*DLA~mh*|Eez~KZxO(xbRaY#Hf7H>d%FQEgE?=(KOsgwCt+BNnp^+Dl`;>Zq
z)xn8<8cxGHT>2bQRX@*jQsgEWDZP+6!JSbDq{AuoRV;me2LXS{=9^0|!VOw9O9!|y#_wZDH!
z5AYF0)U#}8))T3xH#awnno$ubL48`Yv0qCcd|cqJzN&4=l6!9Ppzt4xX!XaVeG%4?MNED
zwO*-!YS(!!^L^Hy=zf1W&d=I#R%dP#lib|ax<74OO29<}y9`yZtZfC6-KKIC#@x>d7&;G=~<(G>aVNG-}1s(!!xz$iA#9eRaCNn@>X&
zVitIfv-*qvN{78^IwUrlRi*H%KlmZJ(4~0QTR-ry?HkkyYP%QIK;``b)JaM`2P#{s
z{{l5YDGnyhBBfWys)vNZHJ6)HKZ)Ck=L55JSaYIob`9w(p`RWrFF%Dt07b)33#GvS`Ac9tEqA`IMalKsOfSKuu6UaoF$I~D^=5qOO^5V&-O@jAM8n^
znTGhx-0zl*M_@ks4tR{0nGNH}bUm#j&f(rD&MrNi60;vN&M7IxEjNg_;W)W!(&gkT
zL_EgH)zfXC<1;XhL+Fnwi>SwqQH|91F7+{37iD3*Mw&NkH_8$Ewp?}12IpnzYDW~C
zSE7sV`MARiM+{f4(VDNq+p_;4^!0XRzVX}Av(!VUzd^C`ZRs_9yLqcK?HW-#cc9#|
z(23=sgPJMReBHfOTOs=fiu~>{2pEnFzq!^!c=|;(-Ypr-oGwat5JAc{or3>{K-Nj2TF1R#2
zW^A~2-SXuNF@{_lKJ!e^!(Tx_X&8USWexREn?!7|6hAb)>WVAYhF7c!N9vYql1=WHdOiGKo}Ux2D7`q+Rh{%}
zbM^T7(xqP4Ev~QontJW6Gi#{+%33mh%G@~%XN;RK(Q9)9Jt6~ikA#k&6b`V0V(6yF
z@>=Bqs0`$;TxN6aohwin$ZaoMM9KED>HO&!zVeb}nTG!Ap@MCPapHpA?PVPAnA3Qx
zV|xCs_fXzPXxXmE4jZZh-MFEqyHur1&9$kRoCoNPQ{o4D
z``}(Zm-9&k(j~^3R{0`i!OXhD_r$lh#FTfOBfb->Q=Oa!8QV{4{gTH9V;*y-!&&EI3b_Hr#s>n2V{tc{E64t$5}
zO)WQYrz=DXdP>_{{>t|9G4#8=9Pe)aOf)}boeX1UMXY?jW_L@?VT7`|{Sdy=$ExSX
zHeTYK1ni8#qaWn(oX0$#^O)ysVZmOG5}diqBSWvvEykITli+PPrBXey>4nHftGrSV
zM^4S(SNiP63T%d|o@mJw(0!35|Ko0Ei9V6D8mdw)T%Csq#Z0n0TNAXllHHssz
zLiAvQC=|y+Coz1TY<*tz!YsIgzuN{xQX%}2ooK7+cIMQ~605q*S~G^1w_D|Np&rI5
z&BWZ|T5DqgcBq7`ne#cPv8pe@1PAHkt`#uyg4=gvcw&`Tl(q+N%q5AF6FDa;dLjB`
zpt*0`+ksxMjVt|#6GOPkzOEl8WH#5~K~QIdf6RY2zx~Cd*1=eL#o*U!Hy`!kAnIlC
z6D00CZ~7@p$*NvtZLElP_H3V+TY|4G(sDhEwxwCi2-7L>!&;1()CF&RkcnfApoLZR
zI%9NF+x|eW-Q%KP_Cyk$D825m9UdfGW_%WH|Ln!Xh|b1}Gw5aQSVoBJQt&bhrChuX
z$0e&q6q2Te-4fb`T**DyLo;=ewOegl#NC)aT~E2&mM3TKB?
zMKCuOXs$}H#lf|;<4O;2t4yzrRixIZW0%{k^o}0*sYplDgkWB@HBj1yc;~Di4(BB}
zPdpP(B^v|GA&!9{RHBXb#r@XIMHR3Nx6Exj%+k}0MRDe?n*g`PJiN0ewe-2*O}Ee;
zj>v7vNwJCs_uaN!RNo!IdOrtEth$eJnik^#;W65R>wA0G9Hl`NK`Qo`<|Ry+O`R?iIk!W
zWyNMrY)S3gT!Y9~Oxczd$-rUCAERuFJ93&j`5WO}y`ZwA2izApT5hR~AQ)-~Z?a=(
z4lIHl+BQ(_V>9Q1krzW7!4AOK%uDc8TpQb1fNh3oG}ZHi+vj4rz}lfxd8tZNJT(8_n4W#{
zZ5BbaJ<#jv@ugqVBRDF#E+^3*mW~xf;XcG&f!4mwZ}ZE!Ifp*~%fYW&e|+)t{3qFk
zpzFRCMOR({??S;XeGx3X6Rc`9{frfO!6NRV7qpffHu9FJ_9xb1_W9ZyR+K)8AajE^
z-T-UFu>^}tKE!uFyfAtexa3CH;wd1C5AJ7NXD&i;*`<41#=M%)m7I@6b?r)W
zO;-~Brd>&{)0JeeA3Q1gW#+~nkFo#Iz61H`^d31ap*BP@*W@BHH+=0mjHlZiH=$Uv
z{Lkg@g%nTCF1B_x&tj8A2NG!bM+e(k*Ny^(#2SRNimyEQs?$mA&`v@U+f!!8EJz-=
zlPJ_q!i~*87#q_uV6_ghvAYLGY+F{thiLo^xPaxw`cxZ3b={^dpYOPtWw6MORnrdr
zzhX16*h(jP<=^o`=f09SyiTGCobf98b1aN2qEAK>xU<_ZtQ&4&jk}2hv1&6i
zYMC22YKBw5;uK$O!I;>B614lQA*iSeDq;(!#}-r~@pc4K+sn(?>a>FBy#RW!bM%9u
z)z&Yzz+VhW(=l3(J~4DR26$F=C0YpvqZ8R%uzbo3tr#=fw6nRWE&;xRs*AzM<3$eG
z8oZ{Y=ye>6Kc?1Nz<~%`L`CgbDEFc`8tSnddHXMrKI>`!(HGy1wjZ{h-TX&3ZtF?B
zx%VQwaS=jUv@-x7v##w=fhW;)<5uKDD&*e{iWPHWZSXgNvRVX19bLY|CW4zig|9UZ
zBXSrd+Z!ZUXC@ZCpzrwRzHG1)!O0$nxN(4#ZS8A&D-%0>;R=s=);_Cxe%o6;iuPKm
z`%00-me4+kRy6dfwPvT*g3LL{Z)MoaJoS;Y21Bj04T`}%G<#bzIkd+>YkvOorO(x;
zZQjK?Vx`cVNE%#(I^M3e#;4N1S_XJ9%8bPm;>=7dE^S*sOmn2HGJhLOJr>`$j@mpi
z`b4UAJ^6TGva?K{!f6h&t=B>9dH*N#6i)MyuNm-+Ia|VL;Wu0x8=qP>_L%8l!wt)-
zwLZB;Sk!7g%kJ7phfH}gc7Nj7E(I}s@pGq0w^ept+n1&KCzR^vI`jaG1Iz!gJM~<4
z>K#`jpK>=2n-D#kxp6=p)g84ZDcH5yoK9{%{o;NGo!e24sAeMxLrdGPJ+EaO+W@NF
zCYJk9bDVnHkw8QGBlt?NsiXHDpB?E4U}$;AXV>Bykn)P)_A{x0Ue4?9lc!rIt^f=j_EjOkYU
zi?wEG^K#}RaGc5yICrr5nX?CqKCH3k%(cEX#;Px=wJt9x-L-y@bu$aPDt}jOGbc(W
z|B+nga--IPIc1waXWNdPWBt+p<%{oW)9Uq!^^(bZ=6i4QUebKWWBUZ{3yk#UXZUWj
zUTWEJ*m})+=Eb9B(PO+w0dDp<9KG~pWA8@;sMh(MarZ&9&JH$iy5SZF<
zc=wLP`Dvucn#{$4o;pE}oY0Yu_JuiCd~b)Tn#h*+8ia-0g<}Uj@JywC
z1FTl66}U*LeZYF9-UDt{ssm`^$nPg%MT$pc>`31@=ipjY0`EPs64g(DX8<*mRl_O
zts+fTo{fKPC}_^m(_{}QD%Rmpbx_9k34DX#qJEm}17$*c3)BeZ{kO}zAWftUypY@h
zs#tA#Exbw5l(!Gmg-SgO%J}?eP^OGN05xB2KL&+}ArC$U
zWqdiSm)RhjCg*@!qP9h#j4vBNT?1Z7CZJ-l=7ppkl;M@ai&g5P4AkXHO#)@yPDXV#
zE-pkBj;h-wE(MQaShITAwSXm?u4-`3Nes-HUYdKEP{n86Wc<$56DEe}k@k72A`?_q
zmHzq-aj<*>nOxlrkf$vHexO$M;I;Nh`7mHQE~RH}9S7`*YvlR)i(3K)NDVM3i-B3P
z4A@sL1D+tOfhP(T;rh#F-~eq|P?ZIps$WV2`Vl8XIN{IK1JFbASI{|f40wv9q%gGs
zV4h?E&yp@vH>{GR#e>rIz?^;`sEHF4uA$`
z2^UsQls&+ZJOk{fXJq8)Hk4EK9EH>L9EF|I0o(7X>VH^|I3FaRf-_h?2jHm`SK?4LU|W>
zv2+425njr0sa~kOKypDZ)Z@+<$pxU7>JjI4LN&2QSq|JHRN871UfXbk9(TS?HiN!V
zEMSXJp?|x44>(SK0~{|e0;lTH=U2$zL0>8V16(KRX!-Th3)mq2fE)Be>#O8s&{szn5jZ6joZMhJ5o2&%hE>{8nUA6UOYR45*EchcPyn4OF9CbVd%!g5
z0H({Az<_iD(PQF&hV)Qkk=BX90-hxg
z0MC{Ofrav0V3D)~i{&}s2>BCml)MTomHogm@(ysU90Zoh5#TuK1WuE5yj^BVZ{Tzp
z2%I6O0n21C@FF=Ec(IHCULuo$m&zr;h4NkC68Rl)sXPf>E>8nj%0PWDou=<8-h{eZ
z&H}EJbAk0z0F20VV1rx)TrYLNjj{%~Np1r+${oO%+yiWu?*oU(qrh9_G2nOPMc{Yk
z81QaM#ry6a9aEvTfliUZz%)4%7?4rGo-!7gA=7}pWInLBECu$FW?)cm2KJT5fw*7;
zc%nQD49UB|e)2xBzrJ}<=6H{$NjflHpjrn1djoq)7BE9j1oo2tz)U#_*jr8p_K{P8
zK^X+hk~4vQF@Ye1bvvS2t;rBPx0@{}E~Jx8rHj(;1?BmILUS}+im)AjFl
z+aB`j{{``9rOM;a@WQw?Iy#I=x`cseDpde1RH_WfKXaIWg;I-vjGNi`!zZ)xXN6Kb
zfE-(=%T6H2N@nBFW~I76P{;YQ4-uHMe`1r*{>pN1k*
z97V`nG}(w2ZH(b~bt>qA-`5CnYEu07*0I}cQT#Z$X|@wkYmD`QS{F{aI?DBQ6V~wX
zVT2EA$f3H;=z`%ozcHa3PJzDb;xW9^aisoqJ;a5sN=D&OSjffwDH%0N%hXQSl6crm
z*K!{{{k@$>gZSX8EOG3tGOo%J(-wF2j_rzWnDcR+P3ErO*9v4Cxwa(C3S}FuzX+8%
z=Jzqg>-mQqGeW9-G6TtEXQXc3
zPE3~x-AUIQw$G*d>!gd_OJaHPs-SpzarT;MeuKwGl?kIP=vx7bZstiMWh%%xk1Q+ZDBav;V(7#t(dXf|
z&sFNmiH~uCIJ<4<4+-%Z(Iq}l!~JtA!}!oQz6oX{KIRR;_>96a%mHxYIX1FnxR#)Y
z!$aTk=;5HeS`#@qB>Uk+4o>ziOX6Vjo6B+1Zer+^1uwRuxmeLj`%F9~mc;`YyD3NI
zd3bT6`7<6LQW>V5zA?>bo+7dczoslk6^@W)327gN)-*qngF~{XyBsIZ#%Cwa+$>JB
zOwoxmhPg>`PQyzTUfDh5jxKTj0Crg_!#LA7_H36R&U^#faV|nX=Eg@$5LXQ}x*R8l
z#vdoF@7Q6jQGc8ma!jD{ack7}gcv^1C5E5F#SS-y^o?VMt%xDt%qE5<1;z41H$IGE
z2{t|6?s6#C!>y}f)G8;=#%CwayiAOyLD7lxSUe@hIe^YrIqK(?Boho*-Lh1Mxk}$&
z$KO9rHDd_8W$gEtk#R!5+V_DIxTQOIIzVdKL8|Og~TGIC`3k
zC7R8~XFGHwj?avk?V=Mgj!Bb-B=ORMN(X`)}5IUXaf?uFAVWgeDmE-R|gdR8S
zca8Cug>mJ?=Vu8%JGs%dhObYE&m#%0s288Gfd{I8s_kjiJM9fT-W@)UfKiOJ1-#0e
zs(I_4U2RVMrhS6St-Ze{(KDf{C|nw^llJA%i<-sj)<6qUPZ(6OF4c
zTu@M8Y^X2nmrCdhzk~e8YgkQp`ocHbcJ5C%yK5R@`Ahui=0o`B$B4H(J>W289)kUI
z_@iM{{^okXah<_PuDkk=Zv-g|c7Ix)8HfavnC2Ty{F8v~KJ&h^1{^H}M^9u$`ZvDw
zQFW|5v-37;`r&JW@z3?i`$d86j3d<$R&Y2!BefdH(U5cIEk~h#-M^8689iro=K?cS
zb-t&riD#%EW+ggBSFn5PinbrCE1WHG^|%LS(+uHqU_g61h8Ewzj;Lx5j#O@Z#>Sr8
z%&-{G;~jBeYRppG?LRa7x#y-4vyC(Ftc9hBSql;6{)2II9x*b+RGUl@^ddgIc=cOB
zC1TGQ8iQ`oHr}3wEc$Hb4X4`@I?;6J4NR}fxNjhG{9NPfRM3BFer`t+KdgD@4!1WG+9`6Zs1?5w}#WEz>ig53>ND*8#&fU-OZR3zX14GBAs4SmQ_}koDSyc
z)m`L}jwJsmcU?Df->gnl)?E>~V)gRKx)n>OtieWywd{$Wn1si6EQ9tE9!
zvDID?$&VgLiR9p0epVf=6%w}l?S_6sCM!WlDwGU(!+fTy2t*I31#jS5g}ooLcJ$13
z!KSytsI}J5tS$XGxaB20*yjMMzm?QBhzH}GJ(x{R#NBYUPF?MUD|~X#^14(2NrKh!mRM;ft?9!rf3{sw_BwAyeJJOZzb
zd*|eu@h%>glT4Hgl8Fe}1~)gNkHH^}!|e8#ANIBUYl=Fp^5W9=NT%ayYHVY%RbG_)=pKUfTu@AQ_$c~*qr!EDNtBIAT9$?(`2+&%~?^MAn
z{9UWynt|=*91O_3I?goA?Ex()dQ{GW%Bs5AE)yY^MW4ul3bWuSO=Kr^&NFa*Mj(15
zWs^TPGqdO^ExB52hUD*sAK}V6YO~f*b4erAvf$J?TER^)(I>J|vnR2lRYZodZVy6n
z=EY0NsYF^D<`#(Bc7F=4wQxL0))(weqta`L&u~hWc+;^Oowomh#-$Ei=PNNtv6H
z=o2A?J4nNEJ#q>O?H2kYdd);F_J)L^HGV&`r`DQ8?QIEexf4&CPAZz6$f`3`eVQGQ
zx8s*K7ULJh!gL=Q!X%m+9(Uj*RI8(L&;sS^*>!$Tq%#?xy!3`sOuQQUt@PEUV1VT$
z0cVdQZ(3$TcMl4Ln(+&Yp?;@Icx4Az$Su{O*>$YI#!X9kPG#K*?ql?cT=hC7*z{Wn
zBeWb`Ch{|oMXd*af*+O?wpCwuXFS!K1}DAV=tB>us*YP#Oi)Zex-&ZqkhbJ3NNACE
z{#&c1Hu`01aLW*ALcxc;&F@m9XkI+yx(Qi_)1|v(<$;>WxteMnF6&?qs&Gh#U?e@%
zu~BiS#2sc+>o*c-QF=O+Zb}jD#FlW<=c&u=_HFae^)CoF740jvQtO8awifx5r8(@E
zNWWT~_!tS+;>5s6&)Tv6#t0fnT-6hzsaC~Ms0L