// in the current image. False is returned if the images are identical.
bool Magick::Image::compare ( const Image &reference_ )
{
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
modifyImage();
Image ref = reference_;
ref.modifyImage();
- return static_cast<bool>(IsImagesEqual(image(), ref.image()));
+ bool status =
+ static_cast<bool>(IsImagesEqual(image(), ref.image(), &exceptionInfo));
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
+ return status;
}
// Composite two images
// Cycle Color Map
void Magick::Image::cycleColormap ( const ssize_t amount_ )
{
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
modifyImage();
- CycleColormapImage( image(), amount_ );
- throwImageException();
+ CycleColormapImage( image(), amount_, &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Despeckle
// Remap image colors with closest color from reference image
void Magick::Image::map ( const Image &mapImage_ , const bool dither_ )
{
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
modifyImage();
options()->quantizeDither( dither_ );
RemapImage ( options()->quantizeInfo(), image(),
- mapImage_.constImage());
- throwImageException();
+ mapImage_.constImage(), &exceptionInfo);
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Floodfill designated area with replacement alpha value
void Magick::Image::matteFloodfill ( const Color &target_ ,
else
options()->quantizeInfo()->measure_error=MagickFalse;
- QuantizeImage( options()->quantizeInfo(), image() );
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
+ QuantizeImage( options()->quantizeInfo(), image(), &exceptionInfo );
- throwImageException();
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Apply an arithmetic or bitwise operator to the image pixel quantums.
void Magick::Image::segment ( const double clusterThreshold_,
const double smoothingThreshold_ )
{
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
modifyImage();
SegmentImage ( image(),
options()->quantizeColorSpace(),
(MagickBooleanType) options()->verbose(),
clusterThreshold_,
- smoothingThreshold_ );
- throwImageException();
+ smoothingThreshold_, &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
SyncImage( image() );
- throwImageException();
}
// Shade image using distant light source
{
modifyImage();
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
if( clipMask_.isValid() )
{
// Set clip mask
- SetImageClipMask( image(), clipMask_.constImage() );
+ SetImageClipMask( image(), clipMask_.constImage(), &exceptionInfo );
}
else
{
// Unset existing clip mask
- SetImageClipMask( image(), 0 );
+ SetImageClipMask( image(), 0, &exceptionInfo );
}
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
Magick::Image Magick::Image::clipMask ( void ) const
{
- ExceptionInfo exceptionInfo;
- GetExceptionInfo( &exceptionInfo );
- MagickCore::Image* image =
- GetImageClipMask( constImage(), &exceptionInfo );
- throwException( exceptionInfo );
- (void) DestroyExceptionInfo( &exceptionInfo );
- return Magick::Image( image );
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
+ MagickCore::Image* image =
+ GetImageClipMask( constImage(), &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
+ return Magick::Image( image );
}
void Magick::Image::colorFuzz ( const double fuzz_ )
Lock( &_imgRef->_mutexLock );
// Re-calculate image signature if necessary
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
if ( force_ ||
!GetImageProperty(constImage(), "Signature") ||
constImage()->taint )
{
- SignatureImage( const_cast<MagickCore::Image *>(constImage()) );
+ SignatureImage( const_cast<MagickCore::Image *>(constImage()), &exceptionInfo );
}
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
const char *property = GetImageProperty(constImage(), "Signature");
return std::string( property );
}
void Magick::Image::type ( const Magick::ImageType type_)
{
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
modifyImage();
options()->type( type_ );
- SetImageType( image(), type_ );
+ SetImageType( image(), type_, &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
void Magick::Image::verbose ( const bool verboseFlag_ )
*title;
title=InterpretImageProperties(resource_info->image_info,*image,
- resource_info->title);
+ resource_info->title,exception);
(void) CopyMagickString(windows->image.name,title,MaxTextExtent);
title=DestroyString(title);
}
next=GetNextImageInList(next);
}
if (next != (Image *) NULL)
- (void) RemapImages(resources.quantize_info,images,(Image *) NULL);
+ (void) RemapImages(resources.quantize_info,images,(Image *) NULL,
+ exception);
}
/*
Sort images by increasing scene number.
(visual_info->klass == TrueColor) ||
(visual_info->klass == DirectColor))
(void) SetImageType(image_list[scene],image_list[scene]->matte ==
- MagickFalse ? TrueColorType : TrueColorMatteType);
+ MagickFalse ? TrueColorType : TrueColorMatteType,exception);
if ((display_image->columns < image_list[scene]->columns) &&
(display_image->rows < image_list[scene]->rows))
display_image=image_list[scene];
if ((resource_info->map_type != (char *) NULL) ||
(visual_info->klass == TrueColor) || (visual_info->klass == DirectColor))
(void) SetImageType(display_image,display_image->matte == MagickFalse ?
- TrueColorType : TrueColorMatteType);
+ TrueColorType : TrueColorMatteType,exception);
XMakeStandardColormap(display,visual_info,&resources,display_image,map_info,
&pixel);
/*
}
if (next != (Image *) NULL)
(void) RemapImages(resource_info->quantize_info,images,
- (Image *) NULL);
+ (Image *) NULL,exception);
}
/*
Sort images by increasing scene number.
(visual_info->klass == TrueColor) ||
(visual_info->klass == DirectColor))
(void) SetImageType(image_list[scene],image_list[scene]->matte ==
- MagickFalse ? TrueColorType : TrueColorMatteType);
+ MagickFalse ? TrueColorType : TrueColorMatteType,exception);
if ((display_image->columns < image_list[scene]->columns) &&
(display_image->rows < image_list[scene]->rows))
display_image=image_list[scene];
*title;
title=InterpretImageProperties(resource_info->image_info,display_image,
- resource_info->title);
+ resource_info->title,exception);
(void) CopyMagickString(windows->image.name,title,MaxTextExtent);
(void) CopyMagickString(windows->image.icon_name,title,MaxTextExtent);
title=DestroyString(title);
*title;
title=InterpretImageProperties(resource_info->image_info,
- image_list[scene],resource_info->title);
+ image_list[scene],resource_info->title,exception);
(void) CopyMagickString(windows->image.name,title,MaxTextExtent);
title=DestroyString(title);
}
*title;
title=InterpretImageProperties(resource_info->image_info,
- image,resource_info->title);
+ image,resource_info->title,exception);
(void) CopyMagickString(windows->image.name,title,
MaxTextExtent);
title=DestroyString(title);
(void) FormatLocaleString(primitive,MaxTextExtent,
"rectangle 0,0 %g,%.20g",metrics.origin.x,(double) height);
(void) CloneString(&undercolor_info->primitive,primitive);
- (void) DrawImage(image,undercolor_info);
+ (void) DrawImage(image,undercolor_info,exception);
(void) DestroyDrawInfo(undercolor_info);
}
annotate_info->affine.tx=offset.x;
annotate_info->affine.ty-=(draw_info->affine.sy*(metrics.ascent+
metrics.descent-metrics.underline_position));
(void) CloneString(&annotate_info->primitive,primitive);
- (void) DrawImage(image,annotate_info);
+ (void) DrawImage(image,annotate_info,exception);
}
else
if (annotate->decorate == UnderlineDecoration)
annotate_info->affine.ty-=(draw_info->affine.sy*
metrics.underline_position);
(void) CloneString(&annotate_info->primitive,primitive);
- (void) DrawImage(image,annotate_info);
+ (void) DrawImage(image,annotate_info,exception);
}
/*
Annotate image with text.
annotate_info->affine.ty-=(draw_info->affine.sy*(height+
metrics.underline_position+metrics.descent)/2.0);
(void) CloneString(&annotate_info->primitive,primitive);
- (void) DrawImage(image,annotate_info);
+ (void) DrawImage(image,annotate_info,exception);
}
}
/*
annotate_info->affine.tx=offset->x;
annotate_info->affine.ty=offset->y;
(void) ConcatenateString(&annotate_info->primitive,"'");
- (void) DrawImage(image,annotate_info);
+ (void) DrawImage(image,annotate_info,exception);
}
}
/*
% The format of the AcquireImageColormap method is:
%
% MagickBooleanType AcquireImageColormap(Image *image,
-% const size_t colors)
+% const size_t colors,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o colors: the number of colors in the image colormap.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline size_t MagickMax(const size_t x,
}
MagickExport MagickBooleanType AcquireImageColormap(Image *image,
- const size_t colors)
+ const size_t colors,ExceptionInfo *exception)
{
register ssize_t
i;
%
% The format of the CycleColormapImage method is:
%
-% MagickBooleanType CycleColormapImage(Image *image,const ssize_t displace)
+% MagickBooleanType CycleColormapImage(Image *image,const ssize_t displace,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o displace: displace the colormap this amount.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType CycleColormapImage(Image *image,
- const ssize_t displace)
+ const ssize_t displace,ExceptionInfo *exception)
{
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (image->storage_class == DirectClass)
- (void) SetImageType(image,PaletteType);
+ (void) SetImageType(image,PaletteType,exception);
status=MagickTrue;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
%
% The format of the SortColormapByIntensity method is:
%
-% MagickBooleanType SortColormapByIntensity(Image *image)
+% MagickBooleanType SortColormapByIntensity(Image *image,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: A pointer to an Image structure.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
-MagickExport MagickBooleanType SortColormapByIntensity(Image *image)
+MagickExport MagickBooleanType SortColormapByIntensity(Image *image,
+ ExceptionInfo *exception)
{
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
for (i=0; i < (ssize_t) image->colors; i++)
pixels[(ssize_t) image->colormap[i].alpha]=(unsigned short) i;
status=MagickTrue;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
for (y=0; y < (ssize_t) image->rows; y++)
{
#endif
extern MagickExport MagickBooleanType
- AcquireImageColormap(Image *,const size_t),
- CycleColormapImage(Image *,const ssize_t),
- SortColormapByIntensity(Image *);
+ AcquireImageColormap(Image *,const size_t,ExceptionInfo *),
+ CycleColormapImage(Image *,const ssize_t,ExceptionInfo *),
+ SortColormapByIntensity(Image *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
% The format of the IsImagesEqual method is:
%
% MagickBooleanType IsImagesEqual(Image *image,
-% const Image *reconstruct_image)
+% const Image *reconstruct_image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o reconstruct_image: the reconstruct image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType IsImagesEqual(Image *image,
- const Image *reconstruct_image)
+ const Image *reconstruct_image,ExceptionInfo *exception)
{
CacheView
*image_view,
*reconstruct_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
maximum_error=0.0;
mean_error_per_pixel=0.0;
mean_error=0.0;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
reconstruct_view=AcquireCacheView(reconstruct_image);
for (y=0; y < (ssize_t) image->rows; y++)
extern MagickExport MagickBooleanType
GetImageDistortion(Image *,const Image *,const MetricType,double *,
ExceptionInfo *),
- IsImagesEqual(Image *,const Image *);
+ IsImagesEqual(Image *,const Image *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
%
% The format of the HuffmanDecodeImage method is:
%
-% MagickBooleanType HuffmanDecodeImage(Image *image)
+% MagickBooleanType HuffmanDecodeImage(Image *image,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline size_t MagickMax(const size_t x,const size_t y)
return(y);
}
-MagickExport MagickBooleanType HuffmanDecodeImage(Image *image)
+MagickExport MagickBooleanType HuffmanDecodeImage(Image *image,
+ ExceptionInfo *exception)
{
#define HashSize 1021
#define MBHashA 293
const HuffmanTable
*entry;
- ExceptionInfo
- *exception;
-
HuffmanTable
**mb_hash,
**mw_hash;
image->x_resolution=204.0;
image->y_resolution=196.0;
image->units=PixelsPerInchResolution;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
for (y=0; ((y < (ssize_t) image->rows) && (null_lines < 3)); )
{
% The format of the HuffmanEncodeImage method is:
%
% MagickBooleanType HuffmanEncodeImage(const ImageInfo *image_info,
-% Image *image,Image *inject_image)
+% Image *image,Image *inject_image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o inject_image: inject into the image stream.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType HuffmanEncodeImage(const ImageInfo *image_info,
- Image *image,Image *inject_image)
+ Image *image,Image *inject_image,ExceptionInfo *exception)
{
#define HuffmanOutputCode(entry) \
{ \
const HuffmanTable
*entry;
- ExceptionInfo
- *exception;
-
int
k,
runlength;
scanline=(unsigned char *) RelinquishMagickMemory(scanline);
return(MagickFalse);
}
- (void) SetImageType(huffman_image,BilevelType);
+ (void) SetImageType(huffman_image,BilevelType,exception);
byte='\0';
bit=(unsigned char) 0x80;
if (LocaleCompare(image_info->magick,"FAX") != 0)
/*
Compress to 1D Huffman pixels.
*/
- exception=(&huffman_image->exception);
q=scanline;
for (y=0; y < (ssize_t) huffman_image->rows; y++)
{
% The format of the LZWEncodeImage method is:
%
% MagickBooleanType LZWEncodeImage(Image *image,const size_t length,
-% unsigned char *pixels)
+% unsigned char *pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o pixels: the address of an unsigned array of characters containing the
% pixels to compress.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType LZWEncodeImage(Image *image,const size_t length,
- unsigned char *pixels)
+ unsigned char *pixels,ExceptionInfo *exception)
{
#define LZWClr 256UL /* Clear Table Marker */
#define LZWEod 257UL /* End of Data marker */
%
*/
MagickExport MagickBooleanType PackbitsEncodeImage(Image *image,
- const size_t length,unsigned char *pixels)
+ const size_t length,unsigned char *pixels,ExceptionInfo *exception)
{
int
count;
% The format of the ZLIBEncodeImage method is:
%
% MagickBooleanType ZLIBEncodeImage(Image *image,const size_t length,
-% unsigned char *pixels)
+% unsigned char *pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o pixels: the address of an unsigned array of characters containing the
% pixels to compress.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static voidpf AcquireZIPMemory(voidpf context,unsigned int items,
}
MagickExport MagickBooleanType ZLIBEncodeImage(Image *image,const size_t length,
- unsigned char *pixels)
+ unsigned char *pixels,ExceptionInfo *exception)
{
int
status;
Ascii85Info;
extern MagickExport MagickBooleanType
- HuffmanDecodeImage(Image *),
- HuffmanEncodeImage(const ImageInfo *,Image *,Image *),
- LZWEncodeImage(Image *,const size_t,unsigned char *),
- PackbitsEncodeImage(Image *,const size_t,unsigned char *),
- ZLIBEncodeImage(Image *,const size_t,unsigned char *);
+ HuffmanDecodeImage(Image *,ExceptionInfo *),
+ HuffmanEncodeImage(const ImageInfo *,Image *,Image *,ExceptionInfo *),
+ LZWEncodeImage(Image *,const size_t,unsigned char *,ExceptionInfo *),
+ PackbitsEncodeImage(Image *,const size_t,unsigned char *,ExceptionInfo *),
+ ZLIBEncodeImage(Image *,const size_t,unsigned char *,ExceptionInfo *);
extern MagickExport void
Ascii85Encode(Image *,const unsigned char),
image->columns=columns;
image->rows=rows;
(void) SetImageBackgroundColor(image);
- status=ImportImagePixels(image,0,0,columns,rows,map,storage,pixels);
+ status=ImportImagePixels(image,0,0,columns,rows,map,storage,pixels,exception);
if (status == MagickFalse)
- {
- InheritException(exception,&image->exception);
- image=DestroyImage(image);
- }
+ image=DestroyImage(image);
return(image);
}
\f
option=GetImageOption(read_info,"caption");
if (option != (const char *) NULL)
{
- property=InterpretImageProperties(read_info,next,option);
+ property=InterpretImageProperties(read_info,next,option,exception);
(void) SetImageProperty(next,"caption",property);
property=DestroyString(property);
}
option=GetImageOption(read_info,"comment");
if (option != (const char *) NULL)
{
- property=InterpretImageProperties(read_info,next,option);
+ property=InterpretImageProperties(read_info,next,option,exception);
(void) SetImageProperty(next,"comment",property);
property=DestroyString(property);
}
option=GetImageOption(read_info,"label");
if (option != (const char *) NULL)
{
- property=InterpretImageProperties(read_info,next,option);
+ property=InterpretImageProperties(read_info,next,option,exception);
(void) SetImageProperty(next,"label",property);
property=DestroyString(property);
}
decode ? decode : encode);
return((char *) NULL);
}
- command=InterpretImageProperties(image_info,image,commands[0]);
+ command=InterpretImageProperties(image_info,image,commands[0],exception);
if (command == (char *) NULL)
(void) ThrowMagickException(exception,GetMagickModule(),ResourceLimitError,
"MemoryAllocationFailed","`%s'",commands[0]);
return(MagickFalse);
}
magick=InterpretImageProperties(image_info,image,decode != (char *) NULL ?
- delegate_info->encode : delegate_info->decode);
+ delegate_info->encode : delegate_info->decode,exception);
if (magick == (char *) NULL)
{
(void) RelinquishUniqueFileResource(image_info->unique);
}
}
status=MagickFalse;
- command=InterpretImageProperties(image_info,image,commands[i]);
+ command=InterpretImageProperties(image_info,image,commands[i],exception);
if (command != (char *) NULL)
{
/*
XSetCursorState(display,windows,MagickTrue);
XCheckRefreshWindows(display,windows);
(void) SetImageType(*image,(*image)->matte == MagickFalse ?
- GrayscaleType : GrayscaleMatteType);
+ GrayscaleType : GrayscaleMatteType,exception);
XSetCursorState(display,windows,MagickFalse);
if (windows->image.orphan != MagickFalse)
break;
affinity_image=ReadImage(image_info,exception);
if (affinity_image != (Image *) NULL)
{
- (void) RemapImage(&quantize_info,*image,affinity_image);
+ (void) RemapImage(&quantize_info,*image,affinity_image,exception);
affinity_image=DestroyImage(affinity_image);
}
CatchException(exception);
XCheckRefreshWindows(display,windows);
quantize_info.number_colors=StringToUnsignedLong(colors);
quantize_info.dither=status != 0 ? MagickTrue : MagickFalse;
- (void) QuantizeImage(&quantize_info,*image);
+ (void) QuantizeImage(&quantize_info,*image,exception);
XSetCursorState(display,windows,MagickFalse);
if (windows->image.orphan != MagickFalse)
break;
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
(void) SegmentImage(*image,RGBColorspace,MagickFalse,geometry_info.rho,
- geometry_info.sigma);
+ geometry_info.sigma,exception);
XSetCursorState(display,windows,MagickFalse);
if (windows->image.orphan != MagickFalse)
break;
{
(void) DeleteImageProperty(next_image,"label");
(void) SetImageProperty(next_image,"label",InterpretImageProperties(
- read_info,next_image,DefaultTileLabel));
+ read_info,next_image,DefaultTileLabel,exception));
(void) ParseRegionGeometry(next_image,read_info->size,&geometry,
exception);
thumbnail_image=ThumbnailImage(next_image,geometry.width,
*title;
title=InterpretImageProperties(resource_info->image_info,display_image,
- resource_info->title);
+ resource_info->title,exception);
(void) CopyMagickString(windows->image.name,title,MaxTextExtent);
(void) CopyMagickString(windows->image.icon_name,title,MaxTextExtent);
title=DestroyString(title);
% The format of the DrawClipPath method is:
%
% MagickBooleanType DrawClipPath(Image *image,const DrawInfo *draw_info,
-% const char *name)
+% const char *name,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o name: the name of the clip path.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType DrawClipPath(Image *image,
- const DrawInfo *draw_info,const char *name)
+ const DrawInfo *draw_info,const char *name,ExceptionInfo *exception)
{
char
clip_mask[MaxTextExtent];
&image->exception);
if (clip_mask == (Image *) NULL)
return(MagickFalse);
- (void) SetImageClipMask(image,clip_mask);
+ (void) SetImageClipMask(image,clip_mask,exception);
clip_mask=DestroyImage(clip_mask);
}
(void) QueryColorDatabase("#00000000",&image->clip_mask->background_color,
(void) CloneString(&clone_info->primitive,value);
(void) QueryColorDatabase("#ffffff",&clone_info->fill,&image->exception);
clone_info->clip_mask=(char *) NULL;
- status=DrawImage(image->clip_mask,clone_info);
+ status=DrawImage(image->clip_mask,clone_info,exception);
status|=NegateImage(image->clip_mask,MagickFalse,&image->exception);
clone_info=DestroyDrawInfo(clone_info);
if (image->debug != MagickFalse)
%
% The format of the DrawImage method is:
%
-% MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info)
+% MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o draw_info: the draw info.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline MagickBooleanType IsPoint(const char *point)
primitive_info->point=point;
}
-MagickExport MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info)
+MagickExport MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info,
+ ExceptionInfo *exception)
{
#define RenderImageTag "Render/Image"
GetMagickToken(q,&q,token);
(void) CloneString(&graphic_context[n]->clip_mask,token);
(void) DrawClipPath(image,graphic_context[n],
- graphic_context[n]->clip_mask);
+ graphic_context[n]->clip_mask,exception);
break;
}
if (LocaleCompare("clip-rule",keyword) == 0)
(void) FormatLocaleString(pattern,MaxTextExtent,"%s",token);
if (GetImageArtifact(image,pattern) != (const char *) NULL)
(void) DrawPatternPath(image,draw_info,token,
- &graphic_context[n]->fill_pattern);
+ &graphic_context[n]->fill_pattern,exception);
else
{
status=QueryColorDatabase(token,&graphic_context[n]->fill,
if (graphic_context[n]->clip_mask != (char *) NULL)
if (LocaleCompare(graphic_context[n]->clip_mask,
graphic_context[n-1]->clip_mask) != 0)
- (void) SetImageClipMask(image,(Image *) NULL);
+ (void) SetImageClipMask(image,(Image *) NULL,exception);
graphic_context[n]=DestroyDrawInfo(graphic_context[n]);
n--;
break;
(void) FormatLocaleString(pattern,MaxTextExtent,"%s",token);
if (GetImageArtifact(image,pattern) != (const char *) NULL)
(void) DrawPatternPath(image,draw_info,token,
- &graphic_context[n]->stroke_pattern);
+ &graphic_context[n]->stroke_pattern,exception);
else
{
status=QueryColorDatabase(token,&graphic_context[n]->stroke,
(LocaleCompare(graphic_context[n]->clip_mask,
graphic_context[n-1]->clip_mask) != 0))
(void) DrawClipPath(image,graphic_context[n],
- graphic_context[n]->clip_mask);
+ graphic_context[n]->clip_mask,exception);
(void) DrawPrimitive(image,graphic_context[n],primitive_info);
}
if (primitive_info->text != (char *) NULL)
% The format of the DrawPatternPath method is:
%
% MagickBooleanType DrawPatternPath(Image *image,const DrawInfo *draw_info,
-% const char *name,Image **pattern)
+% const char *name,Image **pattern,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType DrawPatternPath(Image *image,
- const DrawInfo *draw_info,const char *name,Image **pattern)
+ const DrawInfo *draw_info,const char *name,Image **pattern,
+ ExceptionInfo *exception)
{
char
property[MaxTextExtent];
clone_info->fill_pattern=NewImageList();
clone_info->stroke_pattern=NewImageList();
(void) CloneString(&clone_info->primitive,path);
- status=DrawImage(*pattern,clone_info);
+ status=DrawImage(*pattern,clone_info,exception);
clone_info=DestroyDrawInfo(clone_info);
if (image->debug != MagickFalse)
(void) LogMagickEvent(DrawEvent,GetMagickModule(),"end pattern-path");
extern MagickExport MagickBooleanType
DrawAffineImage(Image *,const Image *,const AffineMatrix *),
- DrawClipPath(Image *,const DrawInfo *,const char *),
+ DrawClipPath(Image *,const DrawInfo *,const char *,ExceptionInfo *),
DrawGradientImage(Image *,const DrawInfo *),
- DrawImage(Image *,const DrawInfo *),
- DrawPatternPath(Image *,const DrawInfo *,const char *,Image **),
+ DrawImage(Image *,const DrawInfo *,ExceptionInfo *),
+ DrawPatternPath(Image *,const DrawInfo *,const char *,Image **,
+ ExceptionInfo *),
DrawPrimitive(Image *,const DrawInfo *,const PrimitiveInfo *);
extern MagickExport void
colors<<=1;
quantize_info.number_colors=colors;
quantize_info.colorspace=GRAYColorspace;
- (void) QuantizeImage(&quantize_info,preview_image);
+ (void) QuantizeImage(&quantize_info,preview_image,exception);
(void) FormatLocaleString(label,MaxTextExtent,
"-colorspace gray -colors %.20g",(double) colors);
break;
break;
colors<<=1;
quantize_info.number_colors=colors;
- (void) QuantizeImage(&quantize_info,preview_image);
+ (void) QuantizeImage(&quantize_info,preview_image,exception);
(void) FormatLocaleString(label,MaxTextExtent,"colors %.20g",(double)
colors);
break;
break;
threshold+=0.4f;
(void) SegmentImage(preview_image,RGBColorspace,MagickFalse,threshold,
- threshold);
+ threshold,exception);
(void) FormatLocaleString(label,MaxTextExtent,"segment %gx%g",
threshold,threshold);
break;
#define ThrowBinaryException(severity,tag,context) \
{ \
if (image != (Image *) NULL) \
- (void) ThrowMagickException(&image->exception,GetMagickModule(),severity, \
+ (void) ThrowMagickException(exception,GetMagickModule(),severity, \
tag == (const char *) NULL ? "unknown" : tag,"`%s'",context); \
return(MagickFalse); \
}
}
#define ThrowWriterException(severity,tag) \
{ \
- (void) ThrowMagickException(&image->exception,GetMagickModule(),severity, \
+ (void) ThrowMagickException(exception,GetMagickModule(),severity, \
tag == (const char *) NULL ? "unknown" : tag,"`%s'",image->filename); \
if (image_info->adjoin != MagickFalse) \
while (image->previous != (Image *) NULL) \
clone_image=CloneImage(image,0,0,MagickTrue,exception);
if (clone_image == (Image *) NULL)
return((Image *) NULL);
- (void) SetImageType(clone_image,GrayscaleType);
+ (void) SetImageType(clone_image,GrayscaleType,exception);
edge_image=EdgeImage(clone_image,radius,exception);
clone_image=DestroyImage(clone_image);
if (edge_image == (Image *) NULL)
return((Image *) NULL);
(void) NormalizeImage(charcoal_image,exception);
(void) NegateImage(charcoal_image,MagickFalse,exception);
- (void) SetImageType(charcoal_image,GrayscaleType);
+ (void) SetImageType(charcoal_image,GrayscaleType,exception);
return(charcoal_image);
}
\f
return((Image *) NULL);
annotate_info=CloneDrawInfo((const ImageInfo *) NULL,draw_info);
caption=InterpretImageProperties((ImageInfo *) NULL,(Image *) image,
- value);
+ value,exception);
(void) CloneString(&annotate_info->text,caption);
count=FormatMagickCaption(caption_image,annotate_info,MagickTrue,&metrics,
&caption,exception);
"ellipse %g,%g,%g,%g,0.0,360.0",image->columns/2.0,
image->rows/2.0,image->columns/2.0-x,image->rows/2.0-y);
draw_info->primitive=AcquireString(ellipse);
- (void) DrawImage(oval_image,draw_info);
+ (void) DrawImage(oval_image,draw_info,exception);
draw_info=DestroyDrawInfo(draw_info);
blur_image=BlurImage(oval_image,radius,sigma,exception);
oval_image=DestroyImage(oval_image);
quantize_info->number_colors=MaxColormapSize;
quantize_info->dither=MagickFalse;
quantize_info->tree_depth=8;
- (void) QuantizeImage(quantize_info,unique_image);
+ (void) QuantizeImage(quantize_info,unique_image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
}
cube_info=DestroyCubeInfo(image,cube_info);
p=GetVirtualPixels(image,0,0,1,1,exception);
ping=p == (const Quantum *) NULL ? MagickTrue : MagickFalse;
type=GetImageType(image,exception);
- (void) SignatureImage(image);
+ (void) SignatureImage(image,exception);
(void) FormatLocaleFile(file,"Image: %s\n",image->filename);
if (*image->magick_filename != '\0')
if (LocaleCompare(image->magick_filename,image->filename) != 0)
}
(void) FormatLocaleFile(file," %.20gx%.20g %s\n",(double)
tile->magick_columns,(double) tile->magick_rows,tile->magick);
- (void) SignatureImage(tile);
+ (void) SignatureImage(tile,exception);
ResetImagePropertyIterator(tile);
property=GetNextImageProperty(tile);
while (property != (const char *) NULL)
% The format of the ClipImagePath method is:
%
% MagickBooleanType ClipImagePath(Image *image,const char *pathname,
-% const MagickBooleanType inside)
+% const MagickBooleanType inside,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o inside: if non-zero, later operations take effect inside clipping path.
% Otherwise later operations take effect outside clipping path.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport MagickBooleanType ClipImage(Image *image)
+MagickExport MagickBooleanType ClipImage(Image *image,ExceptionInfo *exception)
{
- return(ClipImagePath(image,"#1",MagickTrue));
+ return(ClipImagePath(image,"#1",MagickTrue,exception));
}
MagickExport MagickBooleanType ClipImagePath(Image *image,const char *pathname,
- const MagickBooleanType inside)
+ const MagickBooleanType inside,ExceptionInfo *exception)
{
#define ClipImagePathTag "ClipPath/Image"
(void) NegateImage(clip_mask,MagickFalse,&image->exception);
(void) FormatLocaleString(clip_mask->magick_filename,MaxTextExtent,
"8BIM:1999,2998:%s\nPS",pathname);
- (void) SetImageClipMask(image,clip_mask);
+ (void) SetImageClipMask(image,clip_mask,exception);
clip_mask=DestroyImage(clip_mask);
return(MagickTrue);
}
%
% The format of the SetImageClipMask method is:
%
-% MagickBooleanType SetImageClipMask(Image *image,const Image *clip_mask)
+% MagickBooleanType SetImageClipMask(Image *image,const Image *clip_mask,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o clip_mask: the image clip path.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType SetImageClipMask(Image *image,
- const Image *clip_mask)
+ const Image *clip_mask,ExceptionInfo *exception)
{
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
%
% The format of the SetImageMask method is:
%
-% MagickBooleanType SetImageMask(Image *image,const Image *mask)
+% MagickBooleanType SetImageMask(Image *image,const Image *mask,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o mask: the image mask.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType SetImageMask(Image *image,
- const Image *mask)
+ const Image *mask,ExceptionInfo *exception)
{
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
%
% The format of the SetImageType method is:
%
-% MagickBooleanType SetImageType(Image *image,const ImageType type)
+% MagickBooleanType SetImageType(Image *image,const ImageType type,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o type: Image type.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport MagickBooleanType SetImageType(Image *image,const ImageType type)
+MagickExport MagickBooleanType SetImageType(Image *image,const ImageType type,
+ ExceptionInfo *exception)
{
const char
*artifact;
- ExceptionInfo
- *exception;
-
ImageInfo
*image_info;
artifact=GetImageArtifact(image,"dither");
if (artifact != (const char *) NULL)
(void) SetImageOption(image_info,"dither",artifact);
- exception=(&image->exception);
switch (type)
{
case BilevelType:
quantize_info=AcquireQuantizeInfo(image_info);
quantize_info->number_colors=2;
quantize_info->colorspace=GRAYColorspace;
- status=QuantizeImage(quantize_info,image);
+ status=QuantizeImage(quantize_info,image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
}
image->matte=MagickFalse;
{
quantize_info=AcquireQuantizeInfo(image_info);
quantize_info->number_colors=256;
- status=QuantizeImage(quantize_info,image);
+ status=QuantizeImage(quantize_info,image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
}
image->matte=MagickFalse;
(void) BilevelImage(image,(double) QuantumRange/2.0);
(void) SetPixelChannelMask(image,channel_mask);
quantize_info=AcquireQuantizeInfo(image_info);
- status=QuantizeImage(quantize_info,image);
+ status=QuantizeImage(quantize_info,image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
break;
}
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
quantize_info=AcquireQuantizeInfo(image_info);
quantize_info->colorspace=TransparentColorspace;
- status=QuantizeImage(quantize_info,image);
+ status=QuantizeImage(quantize_info,image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
break;
}
*DestroyImageInfo(ImageInfo *);
extern MagickExport MagickBooleanType
- ClipImage(Image *),
- ClipImagePath(Image *,const char *,const MagickBooleanType),
+ ClipImage(Image *,ExceptionInfo *),
+ ClipImagePath(Image *,const char *,const MagickBooleanType,ExceptionInfo *),
GetImageAlphaChannel(const Image *),
IsTaintImage(const Image *),
IsMagickConflict(const char *),
SeparateImage(Image *),
SetImageAlphaChannel(Image *,const AlphaChannelType,ExceptionInfo *),
SetImageBackgroundColor(Image *),
- SetImageClipMask(Image *,const Image *),
+ SetImageClipMask(Image *,const Image *,ExceptionInfo *),
SetImageColor(Image *,const PixelInfo *),
SetImageExtent(Image *,const size_t,const size_t,ExceptionInfo *),
SetImageInfo(ImageInfo *,const unsigned int,ExceptionInfo *),
- SetImageMask(Image *,const Image *),
+ SetImageMask(Image *,const Image *,ExceptionInfo *),
SetImageOpacity(Image *,const Quantum),
SetImageStorageClass(Image *,const ClassType,ExceptionInfo *),
- SetImageType(Image *,const ImageType),
+ SetImageType(Image *,const ImageType,ExceptionInfo *),
StripImage(Image *),
SyncImage(Image *),
SyncImageSettings(const ImageInfo *,Image *),
geometry,
extract_info;
-
size_t
bevel_width,
border_width,
/*
Determine the number of lines in an next label.
*/
- title=InterpretImageProperties(clone_info,image_list[0],montage_info->title);
+ title=InterpretImageProperties(clone_info,image_list[0],montage_info->title,
+ exception);
title_offset=0;
if (montage_info->title != (char *) NULL)
title_offset=(size_t) (2*(metrics.ascent-metrics.descent)*
% MagickBooleanType ImportImagePixels(Image *image,const ssize_t x_offset,
% const ssize_t y_offset,const size_t columns,
% const size_t rows,const char *map,const StorageType type,
-% const void *pixels)
+% const void *pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% map and type. You must preallocate this array where the expected
% length varies depending on the values of width, height, map, and type.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType ImportImagePixels(Image *image,
const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
const size_t rows,const char *map,const StorageType type,
- const void *pixels)
+ const void *pixels,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
QuantumType
*quantum_map;
if (quantum_map == (QuantumType *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
- exception=(&image->exception);
for (i=0; i < (ssize_t) length; i++)
{
switch (map[i])
ExportImagePixels(const Image *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,void *,ExceptionInfo *),
ImportImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
- const size_t,const char *,const StorageType,const void *),
+ const size_t,const char *,const StorageType,const void *,ExceptionInfo *),
InterpolatePixelChannel(const Image *,const CacheView_ *,
const PixelChannel,const InterpolatePixelMethod,const double,const double,
double *,ExceptionInfo *),
% The format of the InterpretImageProperties method is:
%
% char *InterpretImageProperties(const ImageInfo *image_info,Image *image,
-% const char *embed_text)
+% const char *embed_text,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o embed_text: the address of a character string containing the embedded
% formatting characters.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport char *InterpretImageProperties(const ImageInfo *image_info,
- Image *image,const char *embed_text)
+ Image *image,const char *embed_text,ExceptionInfo *exception)
{
char
filename[MaxTextExtent],
/*
Image bounding box.
*/
- page=GetImageBoundingBox(image,&image->exception);
+ page=GetImageBoundingBox(image,exception);
q+=FormatLocaleString(q,MaxTextExtent,"%.20gx%.20g%+.20g%+.20g",
(double) page.width,(double) page.height,(double) page.x,(double)
page.y);
/*
Image signature.
*/
- (void) SignatureImage(image);
+ (void) SignatureImage(image,exception);
value=GetImageProperty(image,"signature");
if (value == (const char *) NULL)
break;
extern MagickExport char
*GetNextImageProperty(const Image *),
- *InterpretImageProperties(const ImageInfo *,Image *,const char *),
+ *InterpretImageProperties(const ImageInfo *,Image *,const char *,
+ ExceptionInfo *),
*RemoveImageProperty(Image *,const char *);
extern MagickExport const char
*GetNodeInfo(CubeInfo *,const size_t,const size_t,NodeInfo *);
static MagickBooleanType
- AssignImageColors(Image *,CubeInfo *),
+ AssignImageColors(Image *,CubeInfo *,ExceptionInfo *),
ClassifyImageColors(CubeInfo *,const Image *,ExceptionInfo *),
DitherImage(Image *,CubeInfo *),
- SetGrayscaleImage(Image *);
+ SetGrayscaleImage(Image *,ExceptionInfo *);
static size_t
DefineImageColormap(Image *,CubeInfo *,NodeInfo *);
return(id);
}
-static MagickBooleanType AssignImageColors(Image *image,CubeInfo *cube_info)
+static MagickBooleanType AssignImageColors(Image *image,CubeInfo *cube_info,
+ ExceptionInfo *exception)
{
#define AssignImageTag "Assign/Image"
(IsRGBColorspace(image->colorspace) == MagickFalse) &&
(image->colorspace != CMYColorspace))
(void) TransformImageColorspace((Image *) image,RGBColorspace);
- if (AcquireImageColormap(image,cube_info->colors) == MagickFalse)
+ if (AcquireImageColormap(image,cube_info->colors,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
image->colors=0;
%
% The format of the CompressImageColormap method is:
%
-% MagickBooleanType CompressImageColormap(Image *image)
+% MagickBooleanType CompressImageColormap(Image *image,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport MagickBooleanType CompressImageColormap(Image *image)
+MagickExport MagickBooleanType CompressImageColormap(Image *image,
+ ExceptionInfo *exception)
{
QuantizeInfo
quantize_info;
GetQuantizeInfo(&quantize_info);
quantize_info.number_colors=image->colors;
quantize_info.tree_depth=MaxTreeDepth;
- return(QuantizeImage(&quantize_info,image));
+ return(QuantizeImage(&quantize_info,image,exception));
}
\f
/*
% %
% %
% %
-% P o s t e r i z e I m a g e C h a n n e l %
+% P o s t e r i z e I m a g e %
% %
% %
% %
% The format of the PosterizeImage method is:
%
% MagickBooleanType PosterizeImage(Image *image,const size_t levels,
-% const MagickBooleanType dither)
+% const MagickBooleanType dither,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o dither: Set this integer value to something other than zero to dither
% the mapped image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline ssize_t MagickRound(MagickRealType x)
}
MagickExport MagickBooleanType PosterizeImage(Image *image,const size_t levels,
- const MagickBooleanType dither)
+ const MagickBooleanType dither,ExceptionInfo *exception)
{
#define PosterizeImageTag "Posterize/Image"
#define PosterizePixel(pixel) (Quantum) (QuantumRange*(MagickRound( \
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
*/
status=MagickTrue;
progress=0;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
levels,MaxColormapSize+1);
quantize_info->dither=dither;
quantize_info->tree_depth=MaxTreeDepth;
- status=QuantizeImage(quantize_info,image);
+ status=QuantizeImage(quantize_info,image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
return(status);
}
% The format of the QuantizeImage method is:
%
% MagickBooleanType QuantizeImage(const QuantizeInfo *quantize_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType DirectToColormapImage(Image *image,
status=MagickTrue;
number_colors=(size_t) (image->columns*image->rows);
- if (AcquireImageColormap(image,number_colors) == MagickFalse)
+ if (AcquireImageColormap(image,number_colors,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
if (image->colors != number_colors)
}
MagickExport MagickBooleanType QuantizeImage(const QuantizeInfo *quantize_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
CubeInfo
*cube_info;
(void) DirectToColormapImage(image,&image->exception);
if ((IsImageGray(image,&image->exception) != MagickFalse) &&
(image->matte == MagickFalse))
- (void) SetGrayscaleImage(image);
+ (void) SetGrayscaleImage(image,exception);
if ((image->storage_class == PseudoClass) &&
(image->colors <= maximum_colors))
return(MagickTrue);
Reduce the number of colors in the image.
*/
ReduceImageColors(image,cube_info);
- status=AssignImageColors(image,cube_info);
+ status=AssignImageColors(image,cube_info,exception);
}
DestroyCubeInfo(cube_info);
return(status);
% The format of the QuantizeImages method is:
%
% MagickBooleanType QuantizeImages(const QuantizeInfo *quantize_info,
-% Image *images)
+% Image *images,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o images: Specifies a pointer to a list of Image structures.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType QuantizeImages(const QuantizeInfo *quantize_info,
- Image *images)
+ Image *images,ExceptionInfo *exception)
{
CubeInfo
*cube_info;
/*
Handle a single image with QuantizeImage.
*/
- status=QuantizeImage(quantize_info,images);
+ status=QuantizeImage(quantize_info,images,exception);
return(status);
}
status=MagickFalse;
{
progress_monitor=SetImageProgressMonitor(image,(MagickProgressMonitor)
NULL,image->client_data);
- status=AssignImageColors(image,cube_info);
+ status=AssignImageColors(image,cube_info,exception);
if (status == MagickFalse)
break;
(void) SetImageProgressMonitor(image,progress_monitor,
% The format of the RemapImage method is:
%
% MagickBooleanType RemapImage(const QuantizeInfo *quantize_info,
-% Image *image,const Image *remap_image)
+% Image *image,const Image *remap_image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o remap_image: the reference image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType RemapImage(const QuantizeInfo *quantize_info,
- Image *image,const Image *remap_image)
+ Image *image,const Image *remap_image,ExceptionInfo *exception)
{
CubeInfo
*cube_info;
Classify image colors from the reference image.
*/
cube_info->quantize_info->number_colors=cube_info->colors;
- status=AssignImageColors(image,cube_info);
+ status=AssignImageColors(image,cube_info,exception);
}
DestroyCubeInfo(cube_info);
return(status);
% The format of the RemapImage method is:
%
% MagickBooleanType RemapImages(const QuantizeInfo *quantize_info,
-% Image *images,Image *remap_image)
+% Image *images,Image *remap_image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o remap_image: the reference image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType RemapImages(const QuantizeInfo *quantize_info,
- Image *images,const Image *remap_image)
+ Image *images,const Image *remap_image,ExceptionInfo *exception)
{
CubeInfo
*cube_info;
/*
Create a global colormap for an image sequence.
*/
- status=QuantizeImages(quantize_info,images);
+ status=QuantizeImages(quantize_info,images,exception);
return(status);
}
/*
if (cube_info == (CubeInfo *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
- status=ClassifyImageColors(cube_info,remap_image,&image->exception);
+ status=ClassifyImageColors(cube_info,remap_image,exception);
if (status != MagickFalse)
{
/*
image=images;
for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
{
- status=AssignImageColors(image,cube_info);
+ status=AssignImageColors(image,cube_info,exception);
if (status == MagickFalse)
break;
}
%
% The format of the SetGrayscaleImage method is:
%
-% MagickBooleanType SetGrayscaleImage(Image *image)
+% MagickBooleanType SetGrayscaleImage(Image *image,ExceptionInfo *exeption)
%
% A description of each parameter follows:
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
-static MagickBooleanType SetGrayscaleImage(Image *image)
+static MagickBooleanType SetGrayscaleImage(Image *image,
+ ExceptionInfo *exception)
{
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
image->filename);
if (image->storage_class != PseudoClass)
{
- ExceptionInfo
- *exception;
-
for (i=0; i <= (ssize_t) MaxMap; i++)
colormap_index[i]=(-1);
- if (AcquireImageColormap(image,MaxMap+1) == MagickFalse)
+ if (AcquireImageColormap(image,MaxMap+1,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
image->colors=0;
status=MagickTrue;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
image->colormap=(PixelPacket *) RelinquishMagickMemory(image->colormap);
image->colormap=colormap;
status=MagickTrue;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
} QuantizeInfo;
extern MagickExport MagickBooleanType
- CompressImageColormap(Image *),
+ CompressImageColormap(Image *,ExceptionInfo *),
GetImageQuantizeError(Image *),
- PosterizeImage(Image *,const size_t,const MagickBooleanType),
- QuantizeImage(const QuantizeInfo *,Image *),
- QuantizeImages(const QuantizeInfo *,Image *),
- RemapImage(const QuantizeInfo *,Image *,const Image *),
- RemapImages(const QuantizeInfo *,Image *,const Image *);
+ PosterizeImage(Image *,const size_t,const MagickBooleanType,ExceptionInfo *),
+ QuantizeImage(const QuantizeInfo *,Image *,ExceptionInfo *),
+ QuantizeImages(const QuantizeInfo *,Image *,ExceptionInfo *),
+ RemapImage(const QuantizeInfo *,Image *,const Image *,ExceptionInfo *),
+ RemapImages(const QuantizeInfo *,Image *,const Image *,ExceptionInfo *);
extern MagickExport QuantizeInfo
*AcquireQuantizeInfo(const ImageInfo *),
*/
filter_image=DestroyImage(filter_image);
resize_filter=DestroyResizeFilter(resize_filter);
- if ((status == MagickFalse) || (resize_image == (Image *) NULL))
- return((Image *) NULL);
+ if (status == MagickFalse)
+ {
+ resize_image=DestroyImage(resize_image);
+ return((Image *) NULL);
+ }
resize_image->type=image->type;
return(resize_image);
}
% MagickBooleanType Classify(Image *image,short **extrema,
% const MagickRealType cluster_threshold,
% const MagickRealType weighting_exponent,
-% const MagickBooleanType verbose)
+% const MagickBooleanType verbose,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
% o verbose: A value greater than zero prints detailed information about
% the identified classes.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType Classify(Image *image,short **extrema,
const MagickRealType cluster_threshold,
- const MagickRealType weighting_exponent,const MagickBooleanType verbose)
+ const MagickRealType weighting_exponent,const MagickBooleanType verbose,
+ ExceptionInfo *exception)
{
#define SegmentImageTag "Segment/Image"
*last_cluster,
*next_cluster;
- ExceptionInfo
- *exception;
-
ExtentPacket
blue,
green,
status=MagickTrue;
count=0;
progress=0;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
for (y=0; y < (ssize_t) image->rows; y++)
{
/*
Allocate image colormap.
*/
- if (AcquireImageColormap(image,number_clusters) == MagickFalse)
+ if (AcquireImageColormap(image,number_clusters,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
i=0;
%
% MagickBooleanType SegmentImage(Image *image,
% const ColorspaceType colorspace,const MagickBooleanType verbose,
-% const double cluster_threshold,const double smooth_threshold)
+% const double cluster_threshold,const double smooth_threshold,
+% ExceptionInfo *exception)
%
% A description of each parameter follows.
%
% derivative of the histogram. As the value is increased, you can expect a
% smoother second derivative.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType SegmentImage(Image *image,
const ColorspaceType colorspace,const MagickBooleanType verbose,
- const double cluster_threshold,const double smooth_threshold)
+ const double cluster_threshold,const double smooth_threshold,
+ ExceptionInfo *exception)
{
MagickBooleanType
status;
/*
Classify using the fuzzy c-Means technique.
*/
- status=Classify(image,extrema,cluster_threshold,WeightingExponent,verbose);
+ status=Classify(image,extrema,cluster_threshold,WeightingExponent,verbose,
+ exception);
if (IsRGBColorspace(colorspace) == MagickFalse)
(void) TransformImageColorspace(image,colorspace);
/*
GetImageDynamicThreshold(const Image *,const double,const double,
PixelInfo *,ExceptionInfo *),
SegmentImage(Image *,const ColorspaceType,const MagickBooleanType,
- const double,const double);
+ const double,const double,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
SignatureInfo;
extern MagickExport MagickBooleanType
- SignatureImage(Image *);
+ SignatureImage(Image *,ExceptionInfo *exception);
extern MagickExport SignatureInfo
*AcquireSignatureInfo(void),
%
% The format of the SignatureImage method is:
%
-% MagickBooleanType SignatureImage(Image *image)
+% MagickBooleanType SignatureImage(Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport MagickBooleanType SignatureImage(Image *image)
+MagickExport MagickBooleanType SignatureImage(Image *image,
+ ExceptionInfo *exception)
{
CacheView
*image_view;
char
*hex_signature;
- ExceptionInfo
- *exception;
-
QuantumInfo
*quantum_info;
signature_info=AcquireSignatureInfo();
signature=AcquireStringInfo(quantum_info->extent);
pixels=GetQuantumPixels(quantum_info);
- exception=(&image->exception);
image_view=AcquireCacheView(image);
for (y=0; y < (ssize_t) image->rows; y++)
{
#endif
extern MagickExport MagickBooleanType
- SignatureImage(Image *);
+ SignatureImage(Image *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
progress=0;
if (image->sync != MagickFalse)
{
- if (AcquireImageColormap(image,2) == MagickFalse)
+ if (AcquireImageColormap(image,2,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
random_info=AcquireRandomInfoThreadSet();
/*
Create colormap.
*/
- if (AcquireImageColormap(composite_image,number_colors) == MagickFalse)
+ if (AcquireImageColormap(composite_image,number_colors,exception) == MagickFalse)
{
XDestroyImage(ximage);
composite_image=DestroyImage(composite_image);
}
(void) SyncAuthenticPixels(affinity_image,exception);
(void) RemapImage(resource_info->quantize_info,image,
- affinity_image);
+ affinity_image,exception);
}
XGetPixelInfo(display,visual_info,map_info,resource_info,image,
pixel);
*/
quantize_info=(*resource_info->quantize_info);
quantize_info.number_colors=(size_t) visual_info->colormap_size;
- (void) QuantizeImage(&quantize_info,image);
+ (void) QuantizeImage(&quantize_info,image,exception);
}
/*
Free previous and create new colormap.
else
{
if (image_info->verbose != MagickFalse)
- (void) IsImagesEqual(image,reconstruct_image);
+ (void) IsImagesEqual(image,reconstruct_image,exception);
if (*difference_image->magick == '\0')
(void) CopyMagickString(difference_image->magick,image->magick,
MaxTextExtent);
char
*text;
- text=InterpretImageProperties(image_info,difference_image,format);
+ text=InterpretImageProperties(image_info,difference_image,format,
+ exception);
if (text == (char *) NULL)
ThrowCompareException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
char
*text;
- text=InterpretImageProperties(image_info,images,format);
+ text=InterpretImageProperties(image_info,images,format,exception);
if (text == (char *) NULL)
ThrowCompositeException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
char
*text;
- text=InterpretImageProperties(image_info,image,format);
+ text=InterpretImageProperties(image_info,image,format,exception);
if (text == (char *) NULL)
ThrowConvertException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
(void) LogMagickEvent(DrawEvent,GetMagickModule(),"MVG:\n'%s'\n",wand->mvg);
if (wand->image == (Image *) NULL)
ThrowDrawException(WandError,"ContainsNoImages",wand->name);
- status=DrawImage(wand->image,CurrentContext);
- InheritException(wand->exception,&wand->image->exception);
+ status=DrawImage(wand->image,CurrentContext,wand->exception);
CurrentContext->primitive=(char *) NULL;
return(status);
}
char
*text;
- text=InterpretImageProperties(image_info,image,format);
+ text=InterpretImageProperties(image_info,image,format,exception);
if (text == (char *) NULL)
ThrowIdentifyException(ResourceLimitError,
"MemoryAllocationFailed",GetExceptionMessage(errno));
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=ClipImage(wand->images);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=ClipImage(wand->images,wand->exception);
return(status);
}
\f
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=ClipImagePath(wand->images,pathname,inside);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=ClipImagePath(wand->images,pathname,inside,wand->exception);
return(status);
}
\f
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=CycleColormapImage(wand->images,displace);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=CycleColormapImage(wand->images,displace,wand->exception);
return(status);
}
\f
draw_info=DestroyDrawInfo(draw_info);
draw_info=CloneDrawInfo(wand->image_info,(DrawInfo *) NULL);
draw_info->primitive=primitive;
- status=DrawImage(wand->images,draw_info);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=DrawImage(wand->images,draw_info,wand->exception);
draw_info=DestroyDrawInfo(draw_info);
return(status);
}
"ContainsNoImages","`%s'",wand->name);
return((char *) NULL);
}
- status=SignatureImage(wand->images);
+ status=SignatureImage(wand->images,wand->exception);
if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ return((char *) NULL);
value=GetImageProperty(wand->images,"signature");
- if (value != (const char *) NULL)
- return(AcquireString(value));
- InheritException(wand->exception,&wand->images->exception);
- return((char *) NULL);
+ if (value == (const char *) NULL)
+ return((char *) NULL);
+ return(AcquireString(value));
}
\f
/*
%
*/
WandExport MagickBooleanType MagickImportImagePixels(MagickWand *wand,
- const ssize_t x,const ssize_t y,const size_t columns,
- const size_t rows,const char *map,const StorageType storage,
- const void *pixels)
+ const ssize_t x,const ssize_t y,const size_t columns,const size_t rows,
+ const char *map,const StorageType storage,const void *pixels)
{
MagickBooleanType
status;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=ImportImagePixels(wand->images,x,y,columns,rows,map,storage,pixels);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=ImportImagePixels(wand->images,x,y,columns,rows,map,storage,pixels,
+ wand->exception);
return(status);
}
\f
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=PosterizeImage(wand->images,levels,dither);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=PosterizeImage(wand->images,levels,dither,wand->exception);
return(status);
}
\f
quantize_info->tree_depth=treedepth;
quantize_info->colorspace=colorspace;
quantize_info->measure_error=measure_error;
- status=QuantizeImage(quantize_info,wand->images);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=QuantizeImage(quantize_info,wand->images,wand->exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
return(status);
}
quantize_info->tree_depth=treedepth;
quantize_info->colorspace=colorspace;
quantize_info->measure_error=measure_error;
- status=QuantizeImages(quantize_info,wand->images);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=QuantizeImages(quantize_info,wand->images,wand->exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
return(status);
}
quantize_info->dither_method=method;
if (method == NoDitherMethod)
quantize_info->dither=MagickFalse;
- status=RemapImage(quantize_info,wand->images,remap_wand->images);
+ status=RemapImage(quantize_info,wand->images,remap_wand->images,
+ wand->exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
return(status);
}
\f
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
status=SegmentImage(wand->images,colorspace,verbose,cluster_threshold,
- smooth_threshold);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ smooth_threshold,wand->exception);
return(status);
}
\f
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",clip_mask->name);
if (clip_mask->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- return(SetImageClipMask(wand->images,clip_mask->images));
+ return(SetImageClipMask(wand->images,clip_mask->images,wand->exception));
}
\f
/*
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- return(SetImageType(wand->images,image_type));
+ return(SetImageType(wand->images,image_type,wand->exception));
}
\f
/*
flags=ParseGeometry(argv[i+1],&geometry_info);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=geometry_info.rho;
- text=InterpretImageProperties(mogrify_info,*image,argv[i+2]);
- InheritException(exception,&(*image)->exception);
+ text=InterpretImageProperties(mogrify_info,*image,argv[i+2],
+ exception);
if (text == (char *) NULL)
break;
(void) CloneString(&draw_info->text,text);
(void) SyncImageSettings(mogrify_info,*image);
if (*option == '+')
{
- (void) SetImageClipMask(*image,(Image *) NULL);
- InheritException(exception,&(*image)->exception);
+ (void) SetImageClipMask(*image,(Image *) NULL,exception);
break;
}
- (void) ClipImage(*image);
- InheritException(exception,&(*image)->exception);
+ (void) ClipImage(*image,exception);
break;
}
if (LocaleCompare("clip-mask",option+1) == 0)
/*
Remove a mask.
*/
- (void) SetImageMask(*image,(Image *) NULL);
- InheritException(exception,&(*image)->exception);
+ (void) SetImageMask(*image,(Image *) NULL,exception);
break;
}
/*
}
mask_view=DestroyCacheView(mask_view);
mask_image->matte=MagickTrue;
- (void) SetImageClipMask(*image,mask_image);
- mask_image=DestroyImage(mask_image);
+ (void) SetImageClipMask(*image,mask_image,exception);
InheritException(exception,&(*image)->exception);
break;
}
{
(void) SyncImageSettings(mogrify_info,*image);
(void) ClipImagePath(*image,argv[i+1],*option == '-' ? MagickTrue :
- MagickFalse);
- InheritException(exception,&(*image)->exception);
+ MagickFalse,exception);
break;
}
if (LocaleCompare("colorize",option+1) == 0)
break;
if (((*image)->storage_class == DirectClass) ||
(*image)->colors > quantize_info->number_colors)
- (void) QuantizeImage(quantize_info,*image);
+ (void) QuantizeImage(quantize_info,*image,exception);
else
- (void) CompressImageColormap(*image);
- InheritException(exception,&(*image)->exception);
+ (void) CompressImageColormap(*image,exception);
break;
}
if (LocaleCompare("colorspace",option+1) == 0)
Cycle an image colormap.
*/
(void) SyncImageSettings(mogrify_info,*image);
- (void) CycleColormapImage(*image,(ssize_t) StringToLong(argv[i+1]));
- InheritException(exception,&(*image)->exception);
+ (void) CycleColormapImage(*image,(ssize_t) StringToLong(argv[i+1]),
+ exception);
break;
}
break;
resize_args,MagickTrue,exception);
break;
}
- args=InterpretImageProperties(mogrify_info,*image,argv[i+2]);
- InheritException(exception,&(*image)->exception);
+ args=InterpretImageProperties(mogrify_info,*image,argv[i+2],
+ exception);
if (args == (char *) NULL)
break;
p=(char *) args;
*/
(void) SyncImageSettings(mogrify_info,*image);
(void) CloneString(&draw_info->primitive,argv[i+1]);
- (void) DrawImage(*image,draw_info);
- InheritException(exception,&(*image)->exception);
+ (void) DrawImage(*image,draw_info,exception);
break;
}
break;
(void) SyncImageSettings(mogrify_info,*image);
function=(MagickFunction) ParseCommandOption(MagickFunctionOptions,
MagickFalse,argv[i+1]);
- arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2]);
- InheritException(exception,&(*image)->exception);
+ arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2],
+ exception);
if (arguments == (char *) NULL)
break;
p=(char *) arguments;
exception);
break;
}
- text=InterpretImageProperties(mogrify_info,*image,format);
- InheritException(exception,&(*image)->exception);
+ text=InterpretImageProperties(mogrify_info,*image,format,
+ exception);
if (text == (char *) NULL)
break;
(void) fputs(text,stdout);
remap_image=GetImageCache(mogrify_info,argv[i+1],exception);
if (remap_image == (Image *) NULL)
break;
- (void) RemapImage(quantize_info,*image,remap_image);
- InheritException(exception,&(*image)->exception);
+ (void) RemapImage(quantize_info,*image,remap_image,exception);
remap_image=DestroyImage(remap_image);
break;
}
/*
Remove a mask.
*/
- (void) SetImageMask(*image,(Image *) NULL);
- InheritException(exception,&(*image)->exception);
+ (void) SetImageMask(*image,(Image *) NULL,exception);
break;
}
/*
mask=GetImageCache(mogrify_info,argv[i+1],exception);
if (mask == (Image *) NULL)
break;
- (void) SetImageMask(*image,mask);
+ (void) SetImageMask(*image,mask,exception);
mask=DestroyImage(mask);
- InheritException(exception,&(*image)->exception);
break;
}
if (LocaleCompare("matte",option+1) == 0)
if (LocaleCompare("monochrome",option+1) == 0)
{
(void) SyncImageSettings(mogrify_info,*image);
- (void) SetImageType(*image,BilevelType);
- InheritException(exception,&(*image)->exception);
+ (void) SetImageType(*image,BilevelType,exception);
break;
}
if (LocaleCompare("morphology",option+1) == 0)
*/
(void) SyncImageSettings(mogrify_info,*image);
(void) PosterizeImage(*image,StringToUnsignedLong(argv[i+1]),
- quantize_info->dither);
- InheritException(exception,&(*image)->exception);
+ quantize_info->dither,exception);
break;
}
if (LocaleCompare("preview",option+1) == 0)
remap_image=GetImageCache(mogrify_info,argv[i+1],exception);
if (remap_image == (Image *) NULL)
break;
- (void) RemapImage(quantize_info,*image,remap_image);
- InheritException(exception,&(*image)->exception);
+ (void) RemapImage(quantize_info,*image,remap_image,exception);
remap_image=DestroyImage(remap_image);
break;
}
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
(void) SegmentImage(*image,(*image)->colorspace,
- mogrify_info->verbose,geometry_info.rho,geometry_info.sigma);
- InheritException(exception,&(*image)->exception);
+ mogrify_info->verbose,geometry_info.rho,geometry_info.sigma,
+ exception);
break;
}
if (LocaleCompare("set",option+1) == 0)
(void) DeleteImageProperty(*image,argv[i+1]);
break;
}
- value=InterpretImageProperties(mogrify_info,*image,argv[i+2]);
+ value=InterpretImageProperties(mogrify_info,*image,argv[i+2],
+ exception);
if (value == (char *) NULL)
break;
if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
(void) SyncImageSettings(mogrify_info,*image);
method=(SparseColorMethod) ParseCommandOption(
MagickSparseColorOptions,MagickFalse,argv[i+1]);
- arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2]);
- InheritException(exception,&(*image)->exception);
+ arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2],
+ exception);
if (arguments == (char *) NULL)
break;
mogrify_image=SparseColorOption(*image,method,arguments,
type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
argv[i+1]);
(*image)->type=UndefinedType;
- (void) SetImageType(*image,type);
- InheritException(exception,&(*image)->exception);
+ (void) SetImageType(*image,type,exception);
break;
}
break;
*quantize_info;
quantize_info=AcquireQuantizeInfo(image_info);
- (void) RemapImages(quantize_info,images,(Image *) NULL);
+ (void) RemapImages(quantize_info,images,(Image *) NULL,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
}
*backup_filename='\0';
(void) SyncImagesSettings(mogrify_info,*images);
if (*option == '+')
{
- (void) RemapImages(quantize_info,*images,(Image *) NULL);
- InheritException(exception,&(*images)->exception);
+ (void) RemapImages(quantize_info,*images,(Image *) NULL,
+ exception);
break;
}
i++;
status=MagickFalse;
break;
}
- InheritException(exception,&layers->exception);
*images=DestroyImageList(*images);
*images=layers;
layers=OptimizeImageLayers(*images,exception);
status=MagickFalse;
break;
}
- InheritException(exception,&layers->exception);
*images=DestroyImageList(*images);
*images=layers;
layers=(Image *) NULL;
OptimizeImageTransparency(*images,exception);
- InheritException(exception,&(*images)->exception);
- (void) RemapImages(quantize_info,*images,(Image *) NULL);
+ (void) RemapImages(quantize_info,*images,(Image *) NULL,
+ exception);
break;
}
case CompositeLayer:
(void) SyncImagesSettings(mogrify_info,*images);
if (*option == '+')
{
- (void) RemapImages(quantize_info,*images,(Image *) NULL);
- InheritException(exception,&(*images)->exception);
+ (void) RemapImages(quantize_info,*images,(Image *) NULL,
+ exception);
break;
}
i++;
*string;
(void) SyncImagesSettings(mogrify_info,*images);
- string=InterpretImageProperties(mogrify_info,*images,argv[i+1]);
+ string=InterpretImageProperties(mogrify_info,*images,argv[i+1],
+ exception);
if (string == (char *) NULL)
break;
- InheritException(exception,&(*images)->exception);
(void) FormatLocaleFile(stdout,"%s",string);
string=DestroyString(string);
}
char
*text;
- text=InterpretImageProperties(image_info,montage_image,format);
+ text=InterpretImageProperties(image_info,montage_image,format,
+ exception);
if (text == (char *) NULL)
ThrowMontageException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
/*
Include declarations.
*/
-#if !defined(WIN32)
-#define MagickExport
-#endif
-
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
if (SvPOK(sval))
clip_mask=SetupList(aTHX_ SvRV(sval),&info,(SV ***) NULL,exception);
for ( ; image; image=image->next)
- SetImageClipMask(image,clip_mask);
+ SetImageClipMask(image,clip_mask,exception);
break;
}
if (LocaleNCompare(attribute,"colormap",8) == 0)
for ( ; image; image=image->next)
(void) SetImageProperty(image,"Comment",InterpretImageProperties(
info ? info->image_info : (ImageInfo *) NULL,image,
- SvPV(sval,na)));
+ SvPV(sval,na),exception));
break;
}
if (LocaleCompare(attribute,"compression") == 0)
for ( ; image; image=image->next)
(void) SetImageProperty(image,"label",InterpretImageProperties(
info ? info->image_info : (ImageInfo *) NULL,image,
- SvPV(sval,na)));
+ SvPV(sval,na),exception));
break;
}
if (LocaleCompare(attribute,"loop") == 0)
if (SvPOK(sval))
mask=SetupList(aTHX_ SvRV(sval),&info,(SV ***) NULL,exception);
for ( ; image; image=image->next)
- SetImageMask(image,mask);
+ SetImageMask(image,mask,exception);
break;
}
if (LocaleCompare(attribute,"mattecolor") == 0)
if (info)
info->image_info->monochrome=sp != 0 ? MagickTrue : MagickFalse;
for ( ; image; image=image->next)
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
break;
}
if (info)
if (info)
info->image_info->type=(ImageType) sp;
for ( ; image; image=image->next)
- SetImageType(image,(ImageType) sp);
+ SetImageType(image,(ImageType) sp,exception);
break;
}
if (info)
sv=NULL;
if (image->mask == (Image *) NULL)
- ClipImage(image);
+ ClipImage(image,exception);
if (image->mask != (Image *) NULL)
{
AddImageToRegistry(sv,image->mask);
sv=NULL;
if (image->clip_mask == (Image *) NULL)
- ClipImage(image);
+ ClipImage(image,exception);
if (image->clip_mask != (Image *) NULL)
{
AddImageToRegistry(sv,image->clip_mask);
if (image == (Image *) NULL)
break;
- (void) SignatureImage(image);
+ (void) SignatureImage(image,exception);
value=GetImageProperty(image,"Signature");
if (value != (const char *) NULL)
s=newSVpv(value,0);
*meta;
meta=InterpretImageProperties(info ? info->image_info :
- (ImageInfo *) NULL,image,attribute);
+ (ImageInfo *) NULL,image,attribute,exception);
s=newSVpv(meta,0);
PUSHs(s ? sv_2mortal(s) : &sv_undef);
meta=(char *) RelinquishMagickMemory(meta);
OptimizeImageTransparency(image,exception);
InheritException(&(image->exception),exception);
quantize_info=AcquireQuantizeInfo(info->image_info);
- (void) RemapImages(quantize_info,image,(Image *) NULL);
+ (void) RemapImages(quantize_info,image,(Image *) NULL,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
break;
}
argument_list[0].string_reference=(char *) NULL;
(void) SetImageProperty(image,"comment",InterpretImageProperties(
info ? info->image_info : (ImageInfo *) NULL,image,
- argument_list[0].string_reference));
+ argument_list[0].string_reference,exception));
break;
}
case 2: /* Label */
argument_list[0].string_reference=(char *) NULL;
(void) SetImageProperty(image,"label",InterpretImageProperties(
info ? info->image_info : (ImageInfo *) NULL,image,
- argument_list[0].string_reference));
+ argument_list[0].string_reference,exception));
break;
}
case 3: /* AddNoise */
*text;
text=InterpretImageProperties(info ? info->image_info :
- (ImageInfo *) NULL,image,argument_list[0].string_reference);
+ (ImageInfo *) NULL,image,argument_list[0].string_reference,
+ exception);
(void) CloneString(&draw_info->text,text);
text=DestroyString(text);
}
{
if (attribute_flag[0] == 0)
argument_list[0].integer_reference=6;
- (void) CycleColormapImage(image,argument_list[0].integer_reference);
+ (void) CycleColormapImage(image,argument_list[0].integer_reference,
+ exception);
break;
}
case 38: /* Draw */
if (attribute_flag[32] != 0)
draw_info->direction=(DirectionType)
argument_list[32].integer_reference;
- DrawImage(image,draw_info);
+ DrawImage(image,draw_info,exception);
draw_info=DestroyDrawInfo(draw_info);
break;
}
quantize_info->dither_method=(DitherMethod)
argument_list[2].integer_reference;
(void) RemapImages(quantize_info,image,
- argument_list[0].image_reference);
+ argument_list[0].image_reference,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
break;
}
&image->transparent_color,exception);
if (attribute_flag[5] && argument_list[5].integer_reference)
{
- (void) QuantizeImages(quantize_info,image);
+ (void) QuantizeImages(quantize_info,image,exception);
goto PerlException;
}
if (attribute_flag[6] != 0)
if ((image->storage_class == DirectClass) ||
(image->colors > quantize_info->number_colors) ||
(quantize_info->colorspace == GRAYColorspace))
- (void) QuantizeImage(quantize_info,image);
+ (void) QuantizeImage(quantize_info,image,exception);
else
- CompressImageColormap(image);
+ CompressImageColormap(image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
break;
}
verbose=argument_list[4].integer_reference != 0 ?
MagickTrue : MagickFalse;
(void) SegmentImage(image,colorspace,verbose,cluster_threshold,
- smoothing_threshold);
+ smoothing_threshold,exception);
break;
}
case 51: /* Signature */
{
- (void) SignatureImage(image);
+ (void) SignatureImage(image,exception);
break;
}
case 52: /* Solarize */
if (attribute_flag[1] == 0)
argument_list[1].integer_reference=MagickTrue;
(void) ClipImagePath(image,argument_list[0].string_reference,
- argument_list[1].integer_reference != 0 ? MagickTrue : MagickFalse);
+ argument_list[1].integer_reference != 0 ? MagickTrue : MagickFalse,
+ exception);
break;
}
case 75: /* AffineTransform */
if (attribute_flag[1] != 0)
image->fuzz=SiPrefixToDouble(argument_list[1].string_reference,
QuantumRange);
- (void) IsImagesEqual(image,argument_list[0].image_reference);
+ (void) IsImagesEqual(image,argument_list[0].image_reference,
+ exception);
break;
}
case 77: /* AdaptiveThreshold */
if (attribute_flag[1] == 0)
argument_list[1].integer_reference=0;
(void) PosterizeImage(image,argument_list[0].integer_reference,
- argument_list[1].integer_reference ? MagickTrue : MagickFalse);
+ argument_list[1].integer_reference ? MagickTrue : MagickFalse,
+ exception);
break;
}
case 89: /* Shadow */
if (attribute_flag[0] != 0)
(void) SetImageProperty(image,"caption",InterpretImageProperties(
info ? info->image_info : (ImageInfo *) NULL,image,
- argument_list[0].string_reference));
+ argument_list[0].string_reference,exception));
angle=0.0;
if (attribute_flag[1] != 0)
angle=argument_list[1].real_reference;
quantize_info->dither_method=(DitherMethod)
argument_list[2].integer_reference;
(void) RemapImages(quantize_info,image,
- argument_list[0].image_reference);
+ argument_list[0].image_reference,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
break;
}
for (next=image; next; next=next->next)
(void) SetImageProperty(next,"label",InterpretImageProperties(
info ? info->image_info : (ImageInfo *) NULL,next,
- SvPV(ST(i),na)));
+ SvPV(ST(i),na),exception));
break;
}
ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
#!/usr/bin/perl
-# Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization
+# Copyright 1999-20.3 ImageMagick Studio LLC, a non-profit organization
# dedicated to making software imaging solutions freely available.
#
# You may not use this file except in compliance with the License. You may
#
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'ModulusAdd'/,
- 'reference/composite/Add.miff', 0.1, 1.03);
+ 'reference/composite/Add.miff', 0.3, 1.03);
#
# Atop
#
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'Atop'/,
- 'reference/composite/Atop.miff', 0.1, 1.03);
+ 'reference/composite/Atop.miff', 0.3, 1.03);
#
# Bumpmap
#
++$test;
-testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
+testCompositeCompare('gradient:white-black',q/size=>"70x46"/,
'input.miff', q//,q/, gravity=>'Center', compose=>'Bumpmap'/,
- 'reference/composite/Bumpmap.miff', 0.1, 1.03);
+ 'reference/composite/Bumpmap.miff', 0.3, 1.03);
#
# Clear
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'Copy'/,
- 'reference/composite/Copy.miff', 0.1, 1.03);
+ 'reference/composite/Copy.miff', 0.3, 1.03);
#
# CopyBlue
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'CopyBlue'/,
- 'reference/composite/CopyBlue.miff', 0.1, 1.03);
+ 'reference/composite/CopyBlue.miff', 0.3, 1.03);
#
# CopyGreen
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'CopyGreen'/,
- 'reference/composite/CopyGreen.miff', 0.1, 1.03);
+ 'reference/composite/CopyGreen.miff', 0.3, 1.03);
#
# CopyRed
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'CopyRed'/,
- 'reference/composite/CopyRed.miff', 0.1, 1.03);
+ 'reference/composite/CopyRed.miff', 0.3, 1.03);
#
# CopyOpacity
#
++$test;
-testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
+testCompositeCompare('gradient:white-black',q/size=>"70x46"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'CopyOpacity'/,
- 'reference/composite/CopyOpacity.miff', 0.1, 1.03);
+ 'reference/composite/CopyOpacity.miff', 0.3, 1.03);
#
# Difference
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'Difference'/,
- 'reference/composite/Difference.miff', 0.1, 1.03);
+ 'reference/composite/Difference.miff', 0.3, 1.03);
#
# In
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'In'/,
- 'reference/composite/In.miff', 0.1, 1.03);
+ 'reference/composite/In.miff', 0.3, 1.03);
#
# Minus
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'Multiply'/,
- 'reference/composite/Multiply.miff', 0.1, 1.03);
+ 'reference/composite/Multiply.miff', 0.3, 1.03);
#
# Out
#
++$test;
-testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
+testCompositeCompare('gradient:white-black',q/size=>"70x46"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'Out'/,
'reference/composite/Out.miff', 0.3, 1.03);
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'Over'/,
- 'reference/composite/Over.miff', 0.1, 1.03);
+ 'reference/composite/Over.miff', 0.3, 1.03);
#
# Plus
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'Plus'/,
- 'reference/composite/Plus.miff', 0.1, 1.03);
+ 'reference/composite/Plus.miff', 0.3, 1.03);
#
# Subtract
++$test;
testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'ModulusSubtract'/,
- 'reference/composite/Subtract.miff', 0.1, 1.03);
+ 'reference/composite/Subtract.miff', 0.3, 1.03);
#
# Xor
#
++$test;
-testCompositeCompare('gradient:white-black',q/size=>"100x80"/,
+testCompositeCompare('gradient:white-black',q/size=>"70x46"/,
'input.miff', q//, q/, gravity=>'Center', compose=>'Xor'/,
'reference/composite/Xor.miff', 0.3, 1.03);
id=ImageMagick version=1.0
class=DirectClass colors=0 matte=True
-columns=86 rows=78 depth=8
+columns=87 rows=78 depth=8
colorspace=RGB
compression=None quality=0
resolution=72x72
-compose={Over}
-create-date={2008-10-04T20:10:45-04:00}
-modify-date={2008-10-04T20:10:45-04:00}
+date:create={2011-09-04T13:28:40-04:00}
+date:modify={2009-09-05T17:47:34-04:00}
\f
-:\1a\9e\9d\9cÿéééÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ/.,ÿ30.ÿjgdÿ´²°ÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿPPOÿ/.,ÿ50-ÿ82-ÿ92,ÿ~yvÿÆÄÃÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\9b\9b\9bÿ+,+ÿ0.+ÿ40,ÿ70+ÿ80,ÿ7/,ÿH@>ÿ\90\8b\8aÿØÖÖÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßßàÿ-/1ÿ,--ÿ/-+ÿ1,)ÿ4-*ÿ4.+ÿ80-ÿ80-ÿ7/,ÿXQOÿ \9d\9bÿêééÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿFHJÿ+.1ÿ.--ÿ.,(ÿ/+'ÿ/+*ÿ1,+ÿ4-+ÿ6/-ÿ6.+ÿ4,)ÿ4,)ÿjdaÿ³°¯ÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\93\94\93ÿ-/.ÿ../ÿ-.-ÿ-*(ÿ,*)ÿ,**ÿ.**ÿ1++ÿ2,+ÿ2,*ÿ3,)ÿ5.*ÿ4-)ÿ1-'ÿzxtÿÆÅÃÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÜÜÛÿ12-ÿ01-ÿ01.ÿ0.,ÿ.++ÿ+)*ÿ*()ÿ-**ÿ.++ÿ/++ÿ0+)ÿ3-*ÿ4-+ÿ3/*ÿ2/)ÿ41+ÿHE?ÿ\92\90\8bÿÛÚ×ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿOPKÿ45/ÿ53.ÿ64/ÿ41-ÿ1-*ÿ,))ÿ*)*ÿ,*+ÿ-*+ÿ.++ÿ0,,ÿ1,,ÿ2.,ÿ30+ÿ30+ÿ63-ÿ86/ÿ@;/ÿgaVÿ«§ ÿíìëÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\90\91\8dÿ782ÿ883ÿ:83ÿ:72ÿ91-ÿ3-+ÿ-++ÿ+),ÿ+)+ÿ*()ÿ+))ÿ.+,ÿ/-,ÿ0.+ÿ3/+ÿ41,ÿ64/ÿ=7-ÿE=2ÿI@2ÿLA1ÿ\7fthÿĹ³ÿþýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÙÙØÿ782ÿ;;5ÿ><7ÿ@=8ÿA97ÿ<41ÿ50.ÿ0./ÿ+*.ÿ,',ÿ+')ÿ,**ÿ-,-ÿ/,+ÿ1-+ÿ2.+ÿ40-ÿ83-ÿ>6-ÿC:/ÿH=-ÿL@/ÿYB2ÿ\81C3ÿÄ\85|ÿëÊÇÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúúùÿIJEÿ681ÿ>=8ÿB?:ÿD?:ÿC=8ÿ?94ÿ:53ÿ301ÿ0)/ÿ/(,ÿ,))ÿ,+*ÿ.,+ÿ/+*ÿ.*)ÿ0,+ÿ3/.ÿ92.ÿ>5-ÿA6-ÿG;.ÿJC2ÿiD3ÿ\94@0ÿ´@4ÿÓTQÿð\98\99ÿüÛÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\85\85\83ÿ440ÿ994ÿ@>9ÿFA>ÿFB<ÿEA:ÿD>8ÿ?95ÿ:20ÿ6-.ÿ2,,ÿ1.*ÿ//+ÿ.-+ÿ.*)ÿ0+)ÿ0,,ÿ700ÿ<30ÿ>4.ÿC7.ÿF>2ÿOD4ÿr?.ÿ\9a;+ÿ¼F<ÿàCFÿï@Dÿö_cÿô¦¦ÿúíìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÏÏÎÿ0/,ÿ32.ÿ993ÿBA8ÿFD=ÿHD=ÿIC;ÿI?6ÿE<2ÿ@71ÿ;4/ÿ61.ÿ41,ÿ11.ÿ//.ÿ3-*ÿ6.)ÿ81,ÿ;30ÿ;20ÿ>1.ÿD71ÿJ=6ÿZ<1ÿu9*ÿ\98A0ÿÆE?ÿæBCÿú<Aÿî<>ÿË?6ÿÉrfÿ⸲ÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿ:81ÿ41-ÿ43.ÿ:;3ÿCC9ÿIH;ÿKH8ÿKC6ÿJ=1ÿF;.ÿD;1ÿ?91ÿ85.ÿ640ÿ752ÿ:3.ÿ=3,ÿ?4,ÿ?5/ÿ<2.ÿ;/-ÿ?0.ÿ@62ÿH:4ÿ^60ÿ\828-ÿ¤A4ÿÊE=ÿï>?ÿó<>ÿÐ@:ÿ²?-ÿ°?,ÿ©@,ÿÁ\85wÿâÊÅÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\88\85~ÿ=:1ÿ52,ÿ74,ÿ>=4ÿIE9ÿMJ6ÿMJ;ÿNJIÿH@9ÿE<.ÿD:0ÿ>80ÿ95/ÿ:5/ÿ>80ÿB90ÿE;0ÿE:1ÿA8/ÿ<2-ÿ</.ÿ>1,ÿ<70ÿD60ÿg7/ÿ\8d<0ÿ¥A4ÿÌC;ÿçA>ÿË@5ÿ?,ÿ¬?+ÿ¬?+ÿ @+ÿ\96?+ÿ\9bO@ÿÃ\95\8bÿëÛØÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÏÍÉÿJD8ÿA<1ÿ73)ÿ97.ÿG?5ÿTJ8ÿRL=ÿffsÿpn\88ÿUMRÿC9,ÿ@8/ÿ<71ÿ:7-ÿ>9-ÿE</ÿJ>0ÿL?3ÿH=4ÿA7/ÿ=2/ÿ=1.ÿB1-ÿ>2-ÿG/)ÿo7,ÿ\8e=3ÿ\9fA4ÿÆD;ÿÊF;ÿ¥A-ÿ£?,ÿ¦>-ÿ\9f?+ÿ\96>*ÿ\91>-ÿ\90=+ÿ\92<*ÿ§`Qÿϧ ÿöíìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ]VHÿNG:ÿC=2ÿ;6.ÿ@93ÿPD6ÿTG8ÿc_oÿ\95\9bÓÿ\86\85¸ÿSMdÿ@:=ÿ<61ÿ=71ÿ>80ÿD<0ÿL?/ÿO@1ÿM>4ÿF:2ÿA70ÿ?61ÿ@51ÿK,/ÿC+,ÿK1)ÿq;.ÿ\8b@1ÿ\9f@3ÿµF:ÿ¡@2ÿ\98?,ÿ\9d=-ÿ\9b=-ÿ\93=*ÿ\8f>+ÿ\8e=,ÿ\8f<*ÿ\90;*ÿ\94>.ÿ¡?3ÿÉvkÿỶÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\8e\88}ÿWM?ÿOH9ÿE=2ÿ?82ÿF?7ÿRE4ÿZNTÿ\86\8aÀÿ§°úÿ\9d¡ìÿsq\97ÿGCIÿ62'ÿ96.ÿ>;5ÿG?5ÿN@/ÿN=0ÿI:1ÿC:0ÿ?:1ÿ?92ÿK76ÿA40ÿ<3*ÿR1(ÿs:/ÿ\8a;2ÿ\93>0ÿ\98?2ÿ\93>-ÿ\93=+ÿ\96;-ÿ\90<,ÿ\8b<*ÿ\89<+ÿ\8a<,ÿ\8a;,ÿ\8d=-ÿ\97>2ÿ¸@4ÿ¶D7ÿ|A5ÿ\8b\80|ÿÉÈÇÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿËÈÃÿZO@ÿYM?ÿQG8ÿI>2ÿD?6ÿME4ÿSF7ÿjg\82ÿ\99¤æÿ±»þÿ©êÿ\7f\7fªÿJGSÿ;:=ÿ<:/ÿE>/ÿM@/ÿJ?-ÿJ:0ÿD90ÿ=<0ÿ?<1ÿp>=ÿ\8aDGÿk>7ÿR8,ÿ`6,ÿ\82:7ÿ\85:5ÿ\85?4ÿ\8e>2ÿ\8d<.ÿ\8d=-ÿ\8d<-ÿ\87;+ÿ\87:*ÿ\85;,ÿ\85;.ÿ\86=0ÿ\93A0ÿ¶@5ÿÅD:ÿ\92G:ÿE7-ÿ842ÿIECÿ\92\8f\8eÿÚÚÙÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôóòÿcVGÿZM=ÿXL<ÿTI9ÿNE9ÿMG7ÿRG/ÿYQWÿ\88\90Åÿ¨®üÿ³¶ÿÿ®¯÷ÿ\88\85ÈÿZU\80ÿA=FÿA=)ÿGA.ÿI>.ÿB8+ÿ?60ÿ8;1ÿ=>0ÿ\8aC@ÿâHWÿ®;9ÿ\98D;ÿ\99E=ÿ\90>7ÿ\90A>ÿ\84A:ÿ\84@5ÿ\88@0ÿ\86=-ÿ\89<-ÿ\87:-ÿ\829*ÿ\809*ÿ\80:-ÿ\81>4ÿ\8bD8ÿ©D9ÿ¿HBÿ\9dQJÿPA7ÿ954ÿ820ÿ61.ÿ50-ÿWVSÿ¡¡ ÿíììÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\89~sÿZL<ÿ[L<ÿXL;ÿWJ<ÿSI<ÿUJ6ÿWNGÿx{¡ÿ\9f¡ðÿ¨©þÿ¬°ýÿ£¦òÿ\85\83Ìÿa[\90ÿ@?Lÿ=>4ÿ9A:ÿ;AFÿ;@?ÿ63/ÿQ71ÿ\8eB:ÿ±:4ÿµ3*ÿ\9f;$ÿº@6ÿ§?3ÿ¨@3ÿ\9cC5ÿ\90@4ÿ\7f@5ÿ\80;.ÿ\83:+ÿ\82;*ÿz;*ÿw:+ÿz:-ÿ\80?6ÿ\85F?ÿ\99E=ÿ³PKÿ©pfÿpk]ÿAA9ÿ93/ÿ62.ÿ52.ÿ10,ÿ./-ÿ1.-ÿlfgÿº´µÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÅ¿¹ÿ[K:ÿZK:ÿYI:ÿYJ;ÿXK=ÿXL;ÿXL=ÿe`oÿ\8a\8cÀÿ\9a\9bèÿ §øÿ¤¬ñÿ£¤ïÿ\88\8f×ÿck\9aÿOJYÿQDGÿd[rÿeczÿFSRÿ_?8ÿ\96;7ÿª;,ÿ¤8%ÿ¦=%ÿ¬<'ÿ§9+ÿ²>2ÿ°C4ÿ¦?.ÿª?9ÿ\97><ÿ~=3ÿv=-ÿw8)ÿ\7f;0ÿu:.ÿ\7fA5ÿ\86I?ÿ\90KFÿ£\Vÿ£\8bwÿ\88\99\80ÿZfXÿ?=3ÿ53,ÿ13-ÿ.3.ÿ,2.ÿ/0.ÿ4.-ÿ:-/ÿc>>ÿ¶\92\94ÿã×Ýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôóñÿ[K7ÿ[K7ÿYJ8ÿYJ9ÿ[K<ÿ]L<ÿ\N;ÿYOIÿgc{ÿ\82\83µÿ\91\95Üÿ\97¡âÿ\9b âÿ\9c§òÿ\97¡Øÿ\8ek\87ÿ\9eM[ÿºTbÿ¹i\8aÿ´i\8dÿ\9fMRÿ\9eD6ÿ¨<+ÿ©>)ÿ©;'ÿ¸=,ÿ°9+ÿ§;.ÿ@2ÿ©<,ÿ»>2ÿÃ><ÿ¦@?ÿw>5ÿ\8a84ÿ³IFÿ£SMÿ|F9ÿ\86I?ÿ\89QHÿ\8ek^ÿ\91\97~ÿ\8cª\8bÿw\8cvÿSZHÿ9;0ÿ/1*ÿ-1+ÿ,2.ÿ-3/ÿ11/ÿ1,,ÿE21ÿ\7fGAÿ\95fxÿ\8c\84®ÿª©Ãÿàßäÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\86ykÿ]L8ÿ\K6ÿ\K7ÿ\K:ÿ]J;ÿ^M;ÿ\N>ÿYLGÿg_vÿ|x±ÿ\87\86Êÿ\81\85Áÿ\81\83½ÿ§\7f±ÿÆg\83ÿÛDRÿæAFÿèEMÿÙDLÿÐCJÿÄ@7ÿ¬:%ÿ®<)ÿ²:(ÿ¾7*ÿÉ:0ÿ¶:.ÿ®;,ÿ²>0ÿº?3ÿÌ;0ÿê69ÿÖ<;ÿº?=ÿÓ>DÿÌNLÿ\8aQCÿkR?ÿwZGÿ\81oXÿz\97uÿ\82\8aÿ\7f£\84ÿf\83eÿJXCÿ46,ÿ-*'ÿ/.+ÿ-/.ÿ/1.ÿ01.ÿ2.,ÿU4*ÿ\85STÿ\85|ªÿbf\9fÿOGiÿ}z\87ÿÆÈÇÿõõôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÀ¹²ÿ^N<ÿ^M:ÿ]L9ÿ]L9ÿ]L:ÿ]M<ÿ]O;ÿ^N:ÿ^NKÿg\\82ÿ\82{½ÿ\88{µÿuj\9bÿ\92TiÿÜF[ÿæ=Cÿç>?ÿå<<ÿÌ?1ÿÒB;ÿâ=<ÿÆ=2ÿ·<,ÿ¾;-ÿÊ:/ÿ×91ÿÓ93ÿÅ8/ÿÂ;/ÿÃ:/ÿÉ5+ÿÞ3+ÿò.,ÿæ73ÿè55ÿ×5/ÿ¬NCÿlaFÿtgKÿ\92mUÿ¬i^ÿ¥\8bxÿ\8a¨\87ÿq\99vÿ]\7f\ÿISBÿ5.+ÿ1))ÿ1+*ÿ/-+ÿ/0,ÿ/0/ÿ6,+ÿW?=ÿ\7fs\97ÿmr¸ÿKArÿNE^ÿpsvÿ\8a\8e\82ÿ\96\96\8eÿÙÙØÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúùùÿ\M=ÿ_O>ÿ^N=ÿ^M;ÿ^L8ÿ^M9ÿ[O=ÿ]O<ÿ`L<ÿ`NUÿog\8bÿ\99~§ÿ±t ÿ¬IXÿÕ;;ÿø7>ÿèC@ÿæ@GÿÐ>?ÿÎC>ÿç>Aÿß9;ÿÇ>5ÿÉ?3ÿÓ<2ÿÛ90ÿÜ71ÿÜ:5ÿÙ:4ÿ×;2ÿ×:2ÿÝ4+ÿå4,ÿò/)ÿå3%ÿÙ4#ÿÄ?3ÿ\95aMÿ\89eLÿÆ`Xÿò?QÿçDWÿ¾~tÿ\8f\9f~ÿy\94oÿf\85eÿGUDÿ1.*ÿ-')ÿ/)+ÿ0++ÿ/.+ÿ1+0ÿ=56ÿvs\82ÿ\85\89ÉÿZX\9fÿB7dÿLJ[ÿz\80yÿlo_ÿ\81\7f|ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿyobÿ]N>ÿ_QAÿ_P?ÿ_O;ÿ^N7ÿZOBÿ^URÿgWWÿfPOÿiaxÿ\8e\82¨ÿÓz\8eÿíM`ÿÚ<;ÿá?7ÿô>?ÿëBKÿÔACÿÀA:ÿÙA@ÿÞ>=ÿÍ>7ÿÆC7ÿÀ8+ÿÐ5,ÿÚ4,ÿÜ80ÿâ:3ÿß91ÿß?5ÿë5+ÿò-(ÿõ.(ÿæ1%ÿÖ4 ÿÑ6'ÿÆK?ÿÄXNÿèVVÿô;Dÿì8Fÿú7OÿëN]ÿ¿rlÿ\92\91uÿj\8aiÿEQ>ÿ,($ÿ-%(ÿ.(,ÿ1)/ÿ0*0ÿ/((ÿbkSÿ\91\9a¯ÿ|\86¼ÿ]`\88ÿGG\ÿ>DJÿOWNÿWWQÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ²®¨ÿSI9ÿ]P@ÿ`SCÿ`R@ÿ\N?ÿ_TQÿjgxÿwq\90ÿqi\82ÿnq\95ÿ\80\86Çÿ±\85ªÿ÷klÿ÷ANÿÝADÿå@BÿéAFÿÆ=:ÿ¯<.ÿÆ@8ÿÐ72ÿÈ?4ÿÀ=.ÿ¼;,ÿÅ6+ÿÚ40ÿÝ9/ÿÝ6+ÿÖ3'ÿÕ8)ÿå?1ÿø0,ÿù+)ÿê1(ÿÒ6 ÿÓ6#ÿÒ:.ÿÕF?ÿìDHÿç?CÿÉ>9ÿæCGÿý0Gÿõ=UÿåVfÿÄpoÿ\91k_ÿOE4ÿ2*$ÿ)*'ÿ(*,ÿ**/ÿ+''ÿHL4ÿ\83\91wÿ\8f¤\9aÿ\98µ«ÿ{\8f\8cÿl\7f{ÿo\80vÿ^gZÿÄÄÀÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿèèæÿED9ÿQH=ÿ_Q@ÿ`TAÿaVPÿiaoÿvw\9aÿy|²ÿtu´ÿt{ºÿ\82\8aÎÿ\96\8aÑÿ¼x\8bÿíX\ÿò@Pÿã>Eÿà@@ÿÇ?7ÿ«9*ÿ¾?2ÿØ;7ÿËA6ÿ½:(ÿ¾9&ÿÄ:)ÿÙ9/ÿà60ÿà5+ÿÔ4!ÿÈ5!ÿÌ9%ÿæ;2ÿû02ÿì/-ÿÕ2&ÿÍ7$ÿÐ5(ÿ×B;ÿÜIDÿÕ?9ÿ¼<0ÿ¹@3ÿã@Aÿû6Gÿþ3Sÿ÷>`ÿæQlÿÖXlÿ¡HTÿW65ÿ).%ÿ1(+ÿ.&*ÿ31)ÿjuUÿ\8b£sÿ\99½\8bÿ¡Æ¡ÿ\90·\97ÿ\91¯\93ÿz\8ezÿ\8c\90\82ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿSVNÿ=<4ÿUI<ÿ`UDÿhabÿup\8dÿvy«ÿkr³ÿckµÿyzÓÿ\9d\9eÑÿ±®¿ÿ¼§¦ÿÎ\80pÿñTUÿð>FÿÜ:;ÿÄ=3ÿª:*ÿ·<-ÿÛ<8ÿßA<ÿÄ=-ÿÁ:&ÿÆ9&ÿ×7(ÿæ4-ÿê20ÿÙ6+ÿÄ8'ÿÄ8(ÿÏ5)ÿæ51ÿí12ÿÛ2/ÿÖ6,ÿÐ:)ÿÔ;0ÿÝOGÿº=1ÿ¶:'ÿ±:)ÿÀ@5ÿêBEÿûAMÿþ<Vÿþ;fÿþ:oÿðFnÿÊJaÿv:<ÿB-(ÿA,)ÿME5ÿahNÿy\8ffÿ\80¢oÿ\8f¶\81ÿ\8d¶\85ÿ\8a±\86ÿ\83 \80ÿ]iOÿööõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\9a\9c\98ÿ-1*ÿ@;5ÿSI<ÿfcgÿso\93ÿlk¥ÿbe«ÿip½ÿ\86\8dÔÿ°±àÿàݽÿîæ¥ÿÓ¿\92ÿ¹jRÿÝGDÿç;=ÿÊ>3ÿ;,ÿ¶?1ÿÓ72ÿã94ÿßJ>ÿÊB3ÿÈ6'ÿ×4'ÿé6,ÿñ1/ÿþ,2ÿæ1/ÿÎ73ÿØ:6ÿÖ7,ÿÝ7+ÿæ41ÿæ14ÿì40ÿÛ8,ÿÝC;ÿ×FBÿ½;*ÿº9(ÿÅ@6ÿØFEÿïEJÿúBPÿþ@_ÿü>nÿüBtÿýHpÿøYuÿ\91ILÿI:,ÿTM3ÿimKÿi\80Wÿm\91^ÿv\9eiÿ}£oÿ\7f¦xÿ|\9cxÿ`qWÿÈËÄÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿàáßÿ,1&ÿ/1,ÿ><7ÿUUYÿed\86ÿSS\8aÿ\]¤ÿssÆÿ\8f\8dÝÿ§¨ßÿÆÆÛÿÝÙÆÿÛÖ´ÿµ²\91ÿ®l[ÿäQPÿá86ÿÁ:/ÿ¸A7ÿÄB9ÿÒ6,ÿÛ9)ÿâJ=ÿÌ:-ÿØ5,ÿé4.ÿè3,ÿì-$ÿõ**ÿõ*6ÿ÷);ÿä1.ÿÇ7#ÿÎ5&ÿß00ÿò+0ÿã2*ÿÖ=/ÿáLIÿÐ@;ÿÁ9)ÿÄ</ÿÐICÿÕGFÿïEKÿüH[ÿýEgÿþHvÿûItÿûSuÿæXrÿ\7fECÿMH3ÿxtZÿy\89fÿl\89Zÿn\92`ÿl\97gÿt\9drÿx\9avÿh\7fdÿ\86\8d\80ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿYYMÿ45-ÿ24,ÿBD=ÿVWkÿ[[\92ÿef²ÿx{Ðÿ\88\88Ûÿ\94\93Öÿ\9c\9aÔÿ©£Òÿ´«Åÿ\98\96\9cÿ\81unÿ¹kfÿõWZÿß76ÿÃ;3ÿÁRFÿÈJ>ÿÕ6)ÿâ8/ÿØ@3ÿÖ:/ÿë56ÿò06ÿõ/:ÿö*4ÿö'4ÿý\1a5ÿò&2ÿ×2+ÿÏ8(ÿÚ7.ÿÒ6-ÿÒ5(ÿË6%ÿ×I>ÿÙFFÿÑ@7ÿÀ9+ÿÅC6ÿÇG>ÿÚIEÿðOVÿ÷G_ÿýJpÿýM{ÿýOwÿûQsÿßZrÿ\92faÿ¢\96\8aÿ¤©¢ÿ\8a\99\8cÿ\83\95yÿ}\96sÿ\7f\9c~ÿz\98{ÿj\88fÿ\hTÿö÷öÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¤¡\99ÿID8ÿ>>3ÿ?B.ÿLNHÿ[Yuÿqp±ÿ\84\86äÿ\83\84áÿ\86\86Ñÿ\87\85Íÿ\8c\85Ñÿ\94\8cÉÿ\8a\7f®ÿngqÿ|b\ÿÇsnÿðYYÿâ=:ÿ½<2ÿÁSEÿË@4ÿÞ2+ÿá:1ÿÝ=0ÿë43ÿø5@ÿü!.ÿû$2ÿó(;ÿô+Lÿ÷2Kÿð=Hÿç38ÿî65ÿå<3ÿÌ>0ÿÆ8'ÿÒ=/ÿßB@ÿáLJÿÈ90ÿ¿;+ÿ¾@.ÿÃB5ÿØMHÿêRZÿùRjÿûQuÿ÷WyÿûRoÿðVnÿ¾osÿ¶\9b\91ÿàÛÞÿÔÍÞÿÁ¼Äÿ¾»µÿ»¾´ÿ ¬¡ÿs\8aqÿXiOÿÏÒÌÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿæåâÿ[SDÿWN@ÿPK9ÿOM:ÿSR?ÿhf{ÿ\8c\89Ùÿ\8e\8cîÿ\81\81Ðÿ\82\83Íÿ\87\81Õÿ\8c\84Êÿ\87\81®ÿy^pÿcWOÿ\8cTJÿÖe`ÿö\Yÿá?8ÿÄD9ÿÐSDÿÒ1'ÿå94ÿâ;.ÿè3+ÿö9=ÿ÷CHÿñ-1ÿð$+ÿï';ÿø>ZÿûXhÿôGXÿï2>ÿð,/ÿÜ83ÿÏ;1ÿÎ5+ÿâ86ÿèCCÿáKDÿÉ<-ÿ¼:'ÿ¸;+ÿ¿C8ÿÒPMÿï\gÿüVpÿüRtÿýUqÿúThÿøapÿÃhhÿòÙÒÿùôûÿ÷èúÿûïùÿðèçÿÞÕÛÿ¨«©ÿbu]ÿ\92\9b\8bÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿxpcÿe[Kÿ`WGÿ\TDÿ]TBÿaZOÿws\92ÿ\8e\8aÑÿ\81~Áÿ\83\82Áÿ\8c\89Íÿ\8b\83Ãÿ\84} ÿyclÿb[MÿnWDÿÆXVÿítrÿøqmÿÙHAÿÅ=0ÿÍ;-ÿâ@<ÿâ@8ÿâ0&ÿí.+ÿð?AÿìEIÿä54ÿà/0ÿê<Jÿ÷ZeÿïLRÿÖ6<ÿÄ3-ÿÊ:/ÿàFBÿÛ97ÿÞ85ÿß0-ÿÖ6,ÿÏ;/ÿÁ<,ÿ³;+ÿ±;.ÿ¹?2ÿâ\XÿúdpÿüRoÿú\tÿû^mÿýXgÿØNWÿØ\9e\99ÿþþþÿýúÿÿþúþÿþûúÿùðôÿÛÔÙÿ\86\90\84ÿkycÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ«¦\9eÿh_Pÿg^Oÿe\Mÿe[Lÿd\Hÿg]Tÿsizÿzq\92ÿup\9aÿ\80|«ÿ\83z ÿ{q\85ÿma]ÿe[Jÿb^Eÿ¡XMÿÞadÿï\81|ÿñlfÿÆ7,ÿÃ7&ÿÕ?4ÿàFCÿà92ÿæ0*ÿÚ3*ÿÚA@ÿëNSÿêOTÿáEIÿÛ>BÿÞ<>ÿÊ72ÿ£6%ÿ\992\1fÿÇD;ÿÜKGÿÕ<7ÿÒ6+ÿÈ7'ÿÈ8+ÿÐH<ÿ´<.ÿ«9,ÿ:+ÿÉN@ÿîidÿögoÿódrÿðntÿògsÿØgjÿ§gbÿàÆÄÿûúúÿüýþÿþû÷ÿÿûúÿùòöÿÅÃÀÿ\8a\93\84ÿÝàÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâàÝÿi`Qÿi`Qÿi`Qÿh_Pÿi`Oÿh_Kÿg^Pÿla^ÿg]_ÿ`\dÿkdkÿn`\ÿk[Mÿb\Hÿf\Hÿy[FÿÀXTÿïghÿïldÿËA3ÿ¼:$ÿÉ:*ÿÓ8.ÿÖ9/ÿß7/ÿÓ7,ÿÅ9,ÿâLLÿôUaÿòZaÿâCGÿç5;ÿÜ58ÿÓHEÿ¿F@ÿ¹?9ÿÄ97ÿÔD>ÿÇ8+ÿ·8$ÿµ8(ÿÒI?ÿÇ?5ÿ¸8-ÿ«9*ÿ°>.ÿ×[Sÿìfhÿîclÿïpqÿøntÿëy\81ÿ\84raÿ\8d}tÿòååÿûþÿÿüúøÿþù÷ÿýïóÿæÛÚÿÉÇ¿ÿÑÔÎÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿofXÿi`Qÿh_PÿjaQÿj`SÿjaUÿi`Pÿh_Lÿf\Hÿ]XIÿUQEÿ_VEÿj[Gÿj]Jÿi]Mÿv]Kÿ\9aUCÿçPOÿæIEÿÒ=0ÿÆ9&ÿÉ:(ÿÔ6*ÿÎ9+ÿÕ7,ÿÕ9-ÿÂ;*ÿÃ<0ÿÑ=@ÿñXcÿø_eÿó07ÿñ0<ÿöUaÿócmÿÛQTÿàQQÿÛHEÿÌ<2ÿÃ8*ÿ¯8)ÿ¾=3ÿÕ?:ÿØ71ÿÒ92ÿ»8+ÿ¿G=ÿïqtÿólvÿ÷krÿüinÿüizÿ\97\8ezÿQ[AÿÝÇÅÿþüþÿýüýÿþúøÿûòñÿèÚØÿîåÚÿèêáÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¥ \97ÿi`Qÿi_QÿkbSÿjaSÿk_Zÿj_ZÿjaQÿiaKÿf`IÿXTAÿMI7ÿYS@ÿe^Iÿw_Oÿ\8eYLÿ¢L>ÿÐ:3ÿä51ÿÝ1*ÿÖ7&ÿÒ8(ÿÖ4)ÿÌ8*ÿÇ8(ÿÔ9,ÿÇ9)ÿÃ=0ÿÄ;4ÿÕEHÿéV\ÿç?@ÿò1:ÿöEQÿûakÿöZbÿáGDÿÚ?<ÿ×B;ÿÙ=6ÿÓ64ÿÌ83ÿÝF=ÿå40ÿö10ÿã5/ÿ¿7,ÿÝa_ÿùy\81ÿût}ÿýmvÿüWhÿ¹lkÿ_sPÿ¿µ¥ÿûùøÿþýþÿýýüÿýþøÿòíçÿïæØÿ÷öèÿýþûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÚØÕÿhaQÿjaRÿjaRÿjaRÿlaUÿkaUÿkbQÿkaTÿjaSÿf^KÿSO;ÿGI7ÿQS@ÿc_Oÿ\9a[Sÿ·G>ÿ¼7+ÿÚ3,ÿá3*ÿÙ7%ÿÑ9%ÿÛ5*ÿÇ6)ÿÀ<)ÿÎA2ÿÐ<.ÿÆ9+ÿÇ:/ÿÈ;4ÿÕKEÿÓD;ÿâ95ÿî>EÿìCHÿôIMÿß73ÿá74ÿÜ?9ÿÝ>7ÿë27ÿõ4=ÿé>;ÿâ3.ÿú.0ÿö//ÿÜ5,ÿÊF=ÿðtvÿý}\85ÿþr~ÿþSfÿêQdÿ\8a\97rÿ\9d©\85ÿõðæÿÿþÿÿ÷ýùÿïÿñÿüüõÿôðâÿúøáÿüýóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿrl]ÿibRÿicRÿiaRÿjaRÿkbSÿkbPÿkcPÿkaUÿlaRÿe^KÿNM<ÿ@F6ÿBI<ÿjREÿÂKIÿÎ5/ÿÅ9*ÿÜ7-ÿÚ6*ÿÐ9&ÿÔ9*ÿÀ9)ÿ»:)ÿÈ=-ÿÕ@4ÿÈ9)ÿÈ8)ÿÊ8+ÿÎ=2ÿÉ<0ÿÔ3'ÿï-2ÿô,<ÿõ/9ÿñ52ÿë41ÿß71ÿÖ80ÿæ54ÿù1;ÿô6:ÿá4.ÿë1.ÿ÷.0ÿï1,ÿÈ6(ÿÖ]Xÿþ\84\89ÿüt\80ÿýWlÿùA]ÿ\96\80bÿ}\96eÿÅÉ«ÿÛæÒÿÖèÖÿÒñÕÿäóÞÿûûìÿýøãÿüûëÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\9e\9b\91ÿhbRÿjbRÿibRÿibRÿjbSÿkbRÿkbRÿlbTÿmbSÿmbSÿb\LÿHI:ÿ9B3ÿAF3ÿ\8aRCÿÞGFÿÇ<.ÿÌ9)ÿÙ8+ÿÕ7)ÿÔ9*ÿÅ:+ÿ³8&ÿÐ;2ÿÞE<ÿÀ9)ÿÅ9(ÿË7(ÿÒ8+ÿÕ;/ÿÜ4.ÿõ/6ÿü*<ÿû&=ÿþ 9ÿö+4ÿç51ÿÞ:1ÿä84ÿç::ÿê56ÿÞ5-ÿã3+ÿô00ÿõ//ÿ×2'ÿÃH=ÿù\89\8aÿþw\85ÿýXqÿ÷B\ÿ¨VKÿe|Kÿw\85Yÿ\82\99qÿ\91±\89ÿ\94¹\8dÿ«Ï£ÿßèÍÿøïÝÿ÷ïáÿýüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÕÔÐÿgcRÿgcRÿhbRÿhbRÿibRÿjbSÿkbSÿlcSÿmbSÿoaSÿi`Rÿ[VFÿEA1ÿ8A)ÿhK6ÿ¶YLÿßJEÿÊ:,ÿÏ7(ÿÓ8)ÿÔ7)ÿÏ:+ÿ³:)ÿ³6&ÿÔ>5ÿÃ=.ÿ¹9(ÿÇ8*ÿÑ5*ÿÚ5+ÿæ95ÿó3=ÿö-<ÿô,;ÿý$:ÿý%8ÿî17ÿß:4ÿã94ÿé66ÿé65ÿÛ5-ÿá6)ÿó0-ÿù.1ÿè1+ÿÄ;0ÿätrÿýz\86ÿþSpÿû?`ÿÀDNÿVg;ÿq\86Xÿx\8dbÿm\93_ÿu\9deÿ\89¶zÿ¥Å\95ÿ×ÙÁÿîàÕÿõïêÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷÷÷ÿqo_ÿgdRÿgcRÿgcRÿibRÿkbSÿlcTÿlcTÿkbSÿj^Rÿi_Uÿoj^ÿa\HÿDF,ÿyJ<ÿ¾@AÿßQQÿçKJÿÌ9-ÿÎ9*ÿÐ:)ÿÒ9)ÿ»;-ÿ\985\1eÿ·<+ÿÐ>3ÿÑD8ÿÎ=3ÿÕ;4ÿß94ÿè:6ÿï6;ÿí1<ÿë8?ÿï47ÿö09ÿî4;ÿÜ96ÿà:4ÿê54ÿê33ÿà5.ÿÝ6)ÿì2*ÿ÷03ÿõ0.ÿÒ8-ÿÈOKÿûz\86ÿüSoÿþ>dÿº@OÿV\9ÿq\95[ÿ\83 mÿ\7f¥nÿ\82ªoÿ\86¯pÿ\89·uÿ\99²\84ÿÏŶÿÝÏÊÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\98\96\8cÿheVÿgdUÿgdSÿfcRÿjcRÿlcTÿlcTÿkbRÿf^Sÿzuoÿ\9a\99\94ÿ§¤\9cÿ\85\81pÿbQ=ÿ\90G@ÿ½GHÿëcfÿÚJEÿÍ>3ÿÏ=1ÿÒ</ÿÇ<0ÿ\9c7"ÿ\9c:"ÿ½7)ÿÓ90ÿà99ÿà;:ÿè99ÿé97ÿç86ÿð@CÿëMNÿîRMÿì;:ÿå66ÿÝ75ÿÞ95ÿé64ÿï36ÿâ5.ÿÚ7(ÿá6'ÿî3-ÿô11ÿà4,ÿÀ93ÿûw\82ÿüSoÿû>cÿ»>Pÿ]Q:ÿg\85Qÿz dÿ~¥jÿ|¤fÿ\81§iÿ\83±nÿ\84±qÿ¨±\90ÿµ¯ÿöôóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÏÎÊÿheVÿheVÿheVÿgdVÿidTÿkcUÿmdTÿlcRÿke[ÿ\91\92\90ÿÐÒÓÿõ÷øÿÞÝØÿ\90\8b|ÿ=>,ÿh?5ÿ¢GDÿËMLÿÐD@ÿÒD>ÿÖE>ÿÖB;ÿÃ?7ÿ¨=+ÿµ;+ÿÑ:1ÿè9=ÿå7<ÿì6:ÿë69ÿÖ;5ÿÌ=4ÿÙLFÿÒGAÿÝ=9ÿß82ÿß74ÿá87ÿé88ÿò69ÿæ63ÿÖ7)ÿÚ7&ÿâ5&ÿî4+ÿå3)ÿÖ=8ÿì]eÿþNlÿþ<dÿÀGYÿJB.ÿXmGÿw\98`ÿv\9e`ÿu\9d_ÿz¡dÿ}§hÿ\7f°fÿ\90±yÿµ¹¤ÿâàßÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöööÿheVÿheVÿheVÿheVÿheUÿjdXÿmdWÿjdRÿibUÿz|}ÿÏÖØÿþþþÿþþþÿ÷èáÿ\9e\90|ÿAG2ÿ;=.ÿ^?5ÿ¤E@ÿÍA=ÿÏD<ÿÚGDÿãFJÿÐGBÿÎE<ÿßG@ÿäCBÿÕ?=ÿÉ75ÿÔ67ÿÎ62ÿ±8(ÿ³9)ÿÈ;0ÿÝ:7ÿá84ÿâ83ÿæ77ÿé7<ÿî6;ÿë67ÿ×8/ÿÐ8(ÿÕ7%ÿ×8%ÿÛ8&ÿÛ=4ÿñU`ÿþJiÿü=eÿ±HTÿMD1ÿAI0ÿl\84Vÿu\98\ÿp\98Wÿu\9d]ÿz£bÿ{¨]ÿ\85±iÿ\98²\86ÿ«µ«ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\91\8f\85ÿgdUÿheVÿheVÿheVÿidWÿldYÿieSÿmkcÿ\8c\90\95ÿÀÉÎÿðûûÿûþûÿýþóÿíðÔÿ\8b\93rÿAJ3ÿ;81ÿQ:3ÿ©EDÿÓ@@ÿÖB?ÿÝADÿàEGÿåGFÿëABÿãDBÿÁA:ÿ >0ÿ£>2ÿ¤:/ÿ¢;)ÿ¤;'ÿ¸:)ÿÛ;5ÿë69ÿæ77ÿç75ÿê7;ÿë6<ÿë69ÿ×:4ÿÂ8)ÿÅ;(ÿÇ;#ÿÈ;$ÿÖ>4ÿùTfÿþAfÿó;bÿ¦?KÿQD4ÿHF2ÿS`=ÿl\8aQÿh\92Lÿo\98Tÿv\9e\ÿx¤Yÿ~«^ÿ\87«oÿ|\92uÿíïìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÈÈÂÿfdTÿheVÿifWÿieVÿjdVÿlc[ÿlfVÿpqbÿ¢§ªÿÝâæÿùúûÿýþûÿùûïÿøüëÿàãÇÿ\82\86eÿA?-ÿ771ÿXBAÿÇijÿÕIGÿÝCAÿÞCDÿàCCÿãB@ÿãA?ÿÍ@<ÿ\9e=0ÿ\8aC1ÿ\80A/ÿ\86=+ÿ\95>*ÿ£=(ÿÀ9,ÿä96ÿð66ÿè84ÿå93ÿç88ÿé7:ÿÚ=7ÿ¼:,ÿ´<)ÿ¸<(ÿ·9#ÿÑA9ÿõG\ÿþ:eÿôAfÿ\806Bÿ34'ÿ<>,ÿAF*ÿ\pAÿf\8bFÿh\92Kÿq\99Wÿs\9dTÿr\9eSÿz¡^ÿu\91cÿ½Ç¸ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ_fQÿefTÿhfWÿheWÿieVÿlcZÿmfYÿhjSÿ\80\89\86ÿÝäèÿþÿÿÿþþûÿ÷ùñÿøúòÿüûêÿÓ̱ÿb`KÿJJ@ÿ}xuÿȲ®ÿÜ\8e\89ÿÜ<<ÿßACÿÝCDÿÙEBÿÚD>ÿÔB<ÿ«<3ÿ\8a>0ÿ\84<1ÿ\80;1ÿ\83:-ÿ\8a<+ÿ\9c9*ÿ¾90ÿæ<6ÿê;5ÿä=4ÿà<8ÿà;;ÿØ=:ÿ»=1ÿ¦;(ÿ¤;'ÿ¡7#ÿÀ<5ÿýK_ÿù=bÿÊ>Yÿj:@ÿ//+ÿ/4\1eÿQO-ÿn|Qÿb|Jÿb\89Dÿi\91Nÿk\92Oÿf\8fJÿ`\88DÿUq<ÿw\8aiÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÅÉÁÿ\8b\93\82ÿgjVÿhfWÿieVÿldXÿlfZÿgjUÿjvkÿºÄÊÿýþþÿþþüÿóôìÿåêÜÿòôâÿáàÃÿ\7f\80eÿ^gWÿ§§\9fÿéàÞÿùïèÿæ¤\9fÿÒMMÿÖ@AÿÜABÿÕD>ÿÔE<ÿÇ@9ÿ\96<0ÿ\80<1ÿ\8392ÿ\81:1ÿ~;0ÿ\82;-ÿ\919+ÿ°:/ÿÑ=3ÿÛA6ÿÒA9ÿÊ<9ÿÂ>8ÿ¬9,ÿ\9c:)ÿ\939&ÿ\8e7$ÿ³E=ÿòRaÿåG\ÿJTÿL=2ÿ41+ÿ@>,ÿpyJÿ¡µ\80ÿv\90bÿ_\84Aÿg\8eGÿj\8fLÿd\8aGÿ\\81DÿUr?ÿPh:ÿúúùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòòñÿ»»´ÿ\87\82wÿlfXÿle[ÿihWÿdp_ÿ\98¦§ÿèîðÿþþýÿúûñÿèìÛÿçíÔÿäãÊÿ¹· ÿ\93\98\88ÿºÀºÿôñïÿÿýüÿþÿýÿ踱ÿÊYQÿÐ@>ÿÕ@?ÿÑC;ÿÙB:ÿ±?4ÿ\83=,ÿ\81;/ÿ\859/ÿ\82;.ÿ}:-ÿz:+ÿ\7f:+ÿ\9e:-ÿ´</ÿ´;.ÿ«80ÿ\9d8,ÿ\958(ÿ\8f:(ÿ\8b9'ÿ\837#ÿ\9bC9ÿÉVYÿÂRWÿ\90ZPÿB?+ÿ9=&ÿVK5ÿ\86\9beÿªÉ\8aÿ\90¯xÿc\87Gÿj\90Hÿo\94Pÿi\8dHÿd\86Iÿa~Hÿ^wEÿ¾Èµÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿåäâÿ¯¬¦ÿvuiÿdlYÿ\82\91\8fÿ×àæÿþþýÿÿÿöÿóøäÿäëÎÿæäËÿÙÑÄÿÕÍÈÿàßÝÿö÷õÿÿþýÿýÿýÿüúöÿຬÿ°I>ÿÅ<8ÿÓ@=ÿØA<ÿÆA9ÿ\93;-ÿ\80<,ÿ\83:,ÿ\83:+ÿ\80:,ÿ}:-ÿ{:.ÿ\808.ÿ\8b8,ÿ\988(ÿ\927*ÿ\8a9,ÿ\85:*ÿ\83:)ÿ\7f;(ÿ{5#ÿ\82<-ÿ§RKÿ UNÿ\90]Oÿhd>ÿ\k;ÿn\90Vÿ\8c£hÿ\9a»~ÿ\82\9dpÿWt@ÿf\8bDÿp\95Pÿj\8fIÿh\8bKÿe\83Jÿe\80Gÿ\89\9fsÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÕ×Òÿ¬µ²ÿÇÑØÿøûûÿüýöÿùûëÿäéÎÿØ׿ÿãÚÓÿôçêÿÿúþÿýýüÿþþýÿþþüÿþþýÿþþþÿì×Ðÿ¿_VÿÈA:ÿÏB=ÿÌB=ÿ¨>6ÿ\86<.ÿ\80<+ÿ\81:+ÿ~9,ÿ~9-ÿ}:/ÿ|90ÿz8/ÿ\808-ÿ\829+ÿ\7f;,ÿ\7f9+ÿ|8)ÿx:+ÿu6'ÿ\82<.ÿ\92NBÿ\93VKÿ\90\Sÿ\8eqYÿ\81\97_ÿ\86¢bÿo\88Sÿq\81WÿUaDÿDU2ÿa~?ÿk\92Iÿf\8cHÿf\89Hÿe\87Kÿe\85Hÿg\88Gÿõ÷òÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýýÿùûôÿïïÝÿááËÿÌɳÿ×ÏÊÿ÷îóÿþûýÿÿþýÿþþüÿþþüÿþþüÿþýüÿýûüÿãžÿ»\OÿÂ?5ÿÉE<ÿ®?9ÿ\8b<2ÿ\7f</ÿ~:-ÿ}9-ÿ|9/ÿ}9/ÿ|90ÿy80ÿy8.ÿx9.ÿx9.ÿx8-ÿx4)ÿy6+ÿq5)ÿ}</ÿ\90J=ÿ\91SHÿ\95XQÿ\8e]QÿqyTÿL[<ÿ9G+ÿ@F3ÿ78,ÿ9@.ÿZn=ÿi\90Eÿc\8cEÿf\88Eÿi\8dNÿf\8bJÿh\8dHÿÊØ¿ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýýûÿïîåÿÓ˽ÿËÀ¹ÿïçíÿþþþÿþþûÿþþûÿþþüÿþþüÿþýûÿþýúÿúÿýÿçÝÑÿ¸n\ÿ»C5ÿ®D6ÿ\8d@5ÿ\80=3ÿ~;0ÿ}9.ÿ{9/ÿ{:1ÿ{;2ÿv:2ÿt8/ÿs7-ÿt9/ÿt8-ÿr6,ÿp4*ÿn3(ÿu<0ÿ\86P?ÿ\8cRFÿ\9aSPÿ\95]Wÿh_Cÿ1=(ÿ/8/ÿ:=5ÿ76/ÿ7:/ÿIX8ÿj\8aHÿh\91Hÿi\8dJÿk\8fOÿk\92Nÿh\91Gÿ\97¶\80ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõóñÿòîñÿýúþÿýþýÿýþûÿþþüÿþþüÿþþüÿûþüÿûþþÿûýÿÿðãÞÿÆ~lÿ¹>5ÿ¡=9ÿ\85>8ÿ\81;2ÿ}90ÿ{8/ÿ{90ÿy:2ÿt:1ÿn9.ÿm6,ÿn7,ÿo7+ÿo5-ÿm3*ÿj3'ÿo9.ÿ\81MCÿ\8cRJÿ\98QLÿ\8e[TÿnfLÿYjAÿGS;ÿKQAÿ@?.ÿ8:.ÿ;E1ÿh\84Kÿq\98Nÿl\93Oÿk\92Mÿm\96Mÿm\99Mÿz¥\ÿöùôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿýþþÿýþþÿþþüÿþýûÿýýýÿýýþÿþúþÿþüýÿðâÕÿ¸t^ÿ\9f=1ÿ\8d:5ÿx@<ÿu>6ÿv:1ÿv7.ÿv7/ÿs7/ÿj8.ÿh7-ÿh7,ÿi7,ÿl6.ÿk4,ÿh3)ÿf2'ÿ|C:ÿ\91SMÿ\92TMÿ\84^Oÿ]`EÿOe=ÿ[oCÿP]=ÿDH.ÿ9:)ÿ7=-ÿ\qCÿt\98Oÿp\99Rÿo\97Nÿn\99Iÿt£Oÿt¤UÿÓáÊÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþýÿÿýüÿþýùÿþüüÿûþúÿûþøÿþþýÿÿþñÿЪ\96ÿ\9bTDÿ}8,ÿo@5ÿq>5ÿp>3ÿo:0ÿn6,ÿj6/ÿg7/ÿe6,ÿe7-ÿh7.ÿi6.ÿe2)ÿ_.$ÿo8/ÿ\93RNÿ\89ZQÿx^Oÿ_cHÿTjDÿTi@ÿBS-ÿ6@*ÿ9;-ÿ7:/ÿK[:ÿo\90Mÿr\9bOÿp\9bLÿr\9dMÿx¦Vÿt¤Wÿ\99·\89ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþÿÿýýÿÿýýÿýþûÿüûøÿþüüÿ÷óíÿÌ´¥ÿ\83T=ÿl=+ÿn:2ÿr?8ÿo?7ÿj;2ÿk71ÿk60ÿf5/ÿf6.ÿf6-ÿi6/ÿg5-ÿ_/%ÿd4*ÿ\80MGÿwXLÿYRBÿIN<ÿ>K5ÿ<J0ÿ?J/ÿ8<*ÿ9;1ÿ69/ÿ9B.ÿe\81Fÿu\9cOÿp\9dNÿv£Tÿ{¦^ÿl\98Rÿi\90Tÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿýûùÿöíêÿþûûÿþþþÿüúôÿ¿ª\98ÿ\85]Oÿi8/ÿn>6ÿn>7ÿm;5ÿo72ÿk60ÿh7/ÿh80ÿk60ÿj9/ÿf:/ÿh=3ÿjH@ÿUF=ÿ>@1ÿ3>/ÿ/6,ÿ36.ÿ7?/ÿ?G4ÿ8=/ÿ5;0ÿ6:+ÿTe;ÿu\98Pÿp\9ePÿv¦Wÿs\9eYÿe\8eMÿa\89KÿÓÞÎÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþýýÿþþýÿýþþÿù÷ïÿæÛÉÿ¥\8exÿfF4ÿf?2ÿi=3ÿk<4ÿj;3ÿd;1ÿc<2ÿfA6ÿgC4ÿfF3ÿ{dSÿk[Nÿ681ÿ25,ÿ18,ÿ4:/ÿ572ÿ04.ÿ3=0ÿ9E4ÿ3;/ÿ481ÿCI1ÿe~Iÿu\9eWÿu£Zÿi\94Rÿ^\86Hÿc\8aJÿ\9b³\8dÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿþÿýÿÿÿòÿãÞÆÿh[AÿXG-ÿ^H2ÿ_E5ÿ_D5ÿ]C4ÿ^F7ÿP<,ÿ[M8ÿ`N7ÿncMÿmmZÿ7>2ÿ/5,ÿ16,ÿ46*ÿ37,ÿ28/ÿ/8,ÿ5B1ÿ2A0ÿ.3/ÿ89,ÿRb9ÿt\9aVÿt\9cZÿb\89Kÿ\\84Fÿe\8cJÿa\85Iÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüúÿ¼¹ÿqkRÿVN2ÿVM4ÿSN8ÿRL6ÿ\W@ÿML5ÿEH/ÿUS8ÿ__BÿioXÿ=E6ÿ-4*ÿ07,ÿ06*ÿ05*ÿ/7+ÿ/8*ÿ/:+ÿ5B2ÿ3=0ÿ12(ÿ>H-ÿo\90Uÿq\9aVÿ]\80Fÿ\\81Eÿb\88Jÿ_\84HÿÙáÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßÞØÿ \9e\8eÿ_]EÿMN6ÿOT;ÿS]Aÿ=G,ÿAG*ÿcdFÿdjPÿ4@,ÿ06-ÿ17-ÿ06,ÿ/4+ÿ.3,ÿ/3,ÿ.5,ÿ/7,ÿ8A1ÿ48+ÿ6;)ÿbzRÿl\94WÿVxAÿZ|Dÿ`\83Jÿ^\82Iÿ\9c±\91ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÍÎÇÿ\89\8e}ÿEN.ÿGO/ÿHN0ÿTU7ÿccHÿBF2ÿ4:0ÿ4:0ÿ39/ÿ16,ÿ.3,ÿ-2-ÿ.3-ÿ-1,ÿ/5.ÿ4>1ÿ37)ÿO]Eÿi\8b^ÿUxCÿUt@ÿ\|Iÿ^\81Iÿh\86Zÿúûúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþýÿ¼¿²ÿ\88\8drÿ_cDÿ][BÿVR>ÿ?B4ÿ8=4ÿ7=3ÿ6<1ÿ27/ÿ-2-ÿ-2,ÿ,1+ÿ,1+ÿ-7/ÿ1>2ÿ@M:ÿYpRÿGh<ÿNl<ÿUrAÿ_}IÿXvHÿÞãÛÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿïïìÿ±±¥ÿtq^ÿQO8ÿBC5ÿ:>4ÿ8>4ÿ8=5ÿ7;5ÿ372ÿ-2,ÿ*/)ÿ*1+ÿ*5,ÿ2=/ÿ=K6ÿBS8ÿKe=ÿKh<ÿYwGÿ[wIÿ\9b¨\95ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÙÿ\9c\9a\8fÿRQEÿ;>4ÿ8?5ÿ9@9ÿ9>8ÿ494ÿ.3-ÿ+0+ÿ*2*ÿ+5,ÿ0:,ÿ4@,ÿ@R6ÿG_:ÿToFÿ\wOÿYiTÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÈÉÆÿ~\84|ÿ8B5ÿ9@8ÿ9?8ÿ8=8ÿ271ÿ+0*ÿ)/)ÿ,3,ÿ6?4ÿ9E3ÿ?O6ÿQfFÿ\qRÿ>O<ÿÜßÝÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýýýÿµ¸´ÿmrjÿ9A7ÿ9?7ÿ5;5ÿ-3.ÿ+0,ÿ-1.ÿ8?7ÿ7B1ÿ@L6ÿ[iSÿGUDÿ\92\99\93ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿëëêÿ£§¢ÿ]d]ÿ8A8ÿ170ÿ+/.ÿ-3/ÿ7C4ÿ4B,ÿHUAÿKWIÿEMFÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÙÛØÿ\90\94\8eÿELEÿ2>.ÿ6H/ÿ7J2ÿ:K3ÿAN>ÿ5@6ÿàáàÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÅÉÃÿ\87\97{ÿFa;ÿ9L5ÿ:K5ÿ6D4ÿ\9c¢\9cÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿ´»´ÿq~mÿFY?ÿT_Rÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿëíëÿ\9f¦\9eÿ
\ No newline at end of file
+:\1a\9e\9e\9dÿêééÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ0/-ÿ31.ÿkgeÿ´²°ÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿQPOÿ0/-ÿ51-ÿ82-ÿ:3-ÿ~ywÿÆÄÃÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\9b\9b\9cÿ,-,ÿ0/,ÿ50,ÿ81,ÿ80,ÿ80-ÿHA>ÿ\90\8c\8aÿÙ×Öÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿàààÿ./1ÿ--.ÿ0.,ÿ2-)ÿ4.*ÿ5.,ÿ81-ÿ81-ÿ80-ÿYROÿ¡\9d\9cÿëêéÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿFIKÿ+.1ÿ.--ÿ/,)ÿ0+(ÿ0,*ÿ2,+ÿ5.,ÿ70-ÿ7.,ÿ4-*ÿ4,)ÿjdbÿ³±¯ÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\94\95\94ÿ.//ÿ.//ÿ-.-ÿ.+)ÿ-+)ÿ,**ÿ/++ÿ1,+ÿ3,+ÿ3-*ÿ4,*ÿ6.+ÿ4-*ÿ1-'ÿ{ytÿÆÅÃÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÝÝÜÿ12-ÿ11-ÿ11.ÿ1/,ÿ.,+ÿ+)+ÿ*))ÿ-++ÿ/++ÿ0,+ÿ1,*ÿ3-+ÿ5.+ÿ3/*ÿ30)ÿ52+ÿHE?ÿ\93\91\8cÿÛÚØÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿPQLÿ55/ÿ64/ÿ740ÿ51.ÿ2.+ÿ,)*ÿ**+ÿ,*+ÿ-++ÿ/++ÿ0-,ÿ2-,ÿ3.,ÿ30+ÿ41+ÿ63-ÿ960ÿA;0ÿhaWÿ¬¨¡ÿîíëÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\91\91\8eÿ893ÿ994ÿ;83ÿ;72ÿ91.ÿ4.,ÿ.+,ÿ+*,ÿ+),ÿ*))ÿ+)*ÿ/,,ÿ0--ÿ1.+ÿ30,ÿ51-ÿ74/ÿ=7-ÿE>2ÿI@2ÿLA2ÿ\7ftiÿĹ´ÿþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÙÙØÿ893ÿ;<6ÿ>=7ÿ@=8ÿA:7ÿ=52ÿ50.ÿ1//ÿ,+.ÿ,(,ÿ+(*ÿ,*+ÿ.-.ÿ/-+ÿ1-,ÿ2.+ÿ41.ÿ83.ÿ>6.ÿD;/ÿH=.ÿM@0ÿYC3ÿ\82D4ÿÄ\86}ÿìËÈÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúúúÿJJFÿ782ÿ>>9ÿB?:ÿE?;ÿD>9ÿ?95ÿ:64ÿ312ÿ0)/ÿ/)-ÿ-**ÿ-,*ÿ.-+ÿ0,+ÿ.*)ÿ0,,ÿ40.ÿ:3/ÿ>5.ÿB7-ÿG<.ÿKC3ÿiE4ÿ\95A0ÿµA5ÿÓUQÿñ\98\9aÿüÜÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\85\85\84ÿ441ÿ995ÿ@?:ÿFA?ÿGB=ÿFA;ÿD>8ÿ@95ÿ:21ÿ7./ÿ2--ÿ1.*ÿ0/+ÿ/-,ÿ/+)ÿ0+*ÿ1-,ÿ810ÿ<30ÿ>4/ÿC7.ÿF?3ÿOD4ÿs@.ÿ\9a<,ÿ¼G<ÿàDGÿïAEÿö_cÿô¦§ÿúíìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÐÏÏÿ0/-ÿ32/ÿ:94ÿBA9ÿGE=ÿHD=ÿJC;ÿI@6ÿE<2ÿA81ÿ;40ÿ62.ÿ42-ÿ22/ÿ0//ÿ4.*ÿ6.*ÿ91-ÿ<31ÿ;21ÿ?2.ÿD71ÿJ=6ÿZ<2ÿv9+ÿ\99A1ÿÆF@ÿæCDÿû<Aÿî=?ÿË@7ÿÊsgÿâ¹²ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;92ÿ42-ÿ54/ÿ;<4ÿCC:ÿIH;ÿLH8ÿKD7ÿJ>2ÿG<.ÿD;2ÿ@92ÿ95/ÿ740ÿ862ÿ:4/ÿ=3,ÿ@5-ÿ?6/ÿ<3.ÿ<0.ÿ?1/ÿA73ÿI:5ÿ^70ÿ\829.ÿ¤A4ÿËE=ÿï??ÿó=?ÿÐA:ÿ²?-ÿ°?,ÿ©@,ÿÂ\86xÿâËÅÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\88\86\7fÿ>:1ÿ62,ÿ75-ÿ>>4ÿJF9ÿNK7ÿMJ;ÿOJJÿIA9ÿF=/ÿE;0ÿ>80ÿ:5/ÿ:50ÿ>81ÿB90ÿF;0ÿF;1ÿA90ÿ<3-ÿ</.ÿ>1-ÿ<81ÿE61ÿh7/ÿ\8e=0ÿ¦A5ÿÌD<ÿçA?ÿËA5ÿ@,ÿ?+ÿ?,ÿ¡@+ÿ\96?,ÿ\9bP@ÿÃ\95\8cÿëÜØÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÏÍÊÿJE8ÿA<2ÿ73*ÿ:7/ÿH@6ÿUJ9ÿRL>ÿfgtÿqo\88ÿVNRÿD:-ÿ@80ÿ=71ÿ:7.ÿ?9.ÿE<0ÿK>1ÿL?3ÿI=4ÿA80ÿ=20ÿ>1/ÿB2-ÿ>2.ÿH0*ÿp8-ÿ\8f>4ÿ B5ÿÇE<ÿÊF<ÿ¦A.ÿ£?,ÿ¦>-ÿ ?,ÿ\96?+ÿ\91>.ÿ\91=,ÿ\92=+ÿ§aRÿШ¡ÿ÷îíÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ^VHÿNG:ÿC=3ÿ<6.ÿA:4ÿPE7ÿUG9ÿc_pÿ\96\9bÓÿ\86\85¸ÿTMdÿA:=ÿ<71ÿ=71ÿ>90ÿE<1ÿM?/ÿOA2ÿN>4ÿG:2ÿA81ÿ?62ÿ@51ÿL-0ÿC+-ÿK2)ÿq;.ÿ\8cA1ÿ A3ÿ¶F:ÿ¡@2ÿ\99?,ÿ\9d>.ÿ\9c>.ÿ\94>+ÿ\8f>+ÿ\8e=,ÿ\90=+ÿ\91<*ÿ\94?/ÿ¡@3ÿÉvlÿá¼·ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\8f\88~ÿWN@ÿPH:ÿF>3ÿ@92ÿF@7ÿSF5ÿZOTÿ\86\8aÁÿ¨°ûÿ\9d¡ìÿsq\97ÿGCJÿ62(ÿ:6/ÿ?<6ÿH@5ÿOA0ÿN>1ÿJ;1ÿC:0ÿ?;2ÿ@92ÿL86ÿB40ÿ=3*ÿS2)ÿs:0ÿ\8a<2ÿ\94>0ÿ\99@2ÿ\93>.ÿ\94=+ÿ\97<-ÿ\91=-ÿ\8b=+ÿ\8a=,ÿ\8a<-ÿ\8b;-ÿ\8d>.ÿ\98>3ÿ¹A4ÿ·D7ÿ|B6ÿ\8c\81|ÿÉÈÈÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÌÈÃÿ[O@ÿYN?ÿQG9ÿI?3ÿE@7ÿME4ÿTF7ÿjg\83ÿ\9a¥æÿ±¼ÿÿ©êÿ\80\80«ÿJGTÿ<:>ÿ=:0ÿF>/ÿN@/ÿJ?-ÿJ:0ÿD91ÿ==1ÿ?<2ÿp?>ÿ\8bDGÿk>8ÿS8,ÿa6-ÿ\82;7ÿ\86;5ÿ\86@4ÿ\8e?2ÿ\8d=.ÿ\8d=.ÿ\8d<.ÿ\88;,ÿ\87:*ÿ\86;,ÿ\85</ÿ\86>1ÿ\94A1ÿ¶A5ÿÆD;ÿ\92H;ÿF7.ÿ943ÿJEDÿ\92\90\8eÿÛÚÚÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôôóÿcWGÿZN>ÿYM=ÿUI:ÿOF:ÿNG8ÿSG/ÿYRWÿ\88\90Æÿ©¯üÿ³·ÿÿ®°÷ÿ\89\86ÈÿZU\81ÿB>GÿB=)ÿHA/ÿI>.ÿB9+ÿ@60ÿ9;1ÿ=>0ÿ\8aDAÿâHXÿ®<:ÿ\98E;ÿ\9aE=ÿ\91?7ÿ\91A?ÿ\84B:ÿ\85A6ÿ\88@0ÿ\87>-ÿ\89<.ÿ\87:-ÿ\83:+ÿ\819*ÿ\80:.ÿ\81>5ÿ\8cD9ÿ©E:ÿ¿HCÿ\9eQJÿPA7ÿ:64ÿ931ÿ62/ÿ51-ÿXVSÿ¡¡ ÿíííÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\8a\7fsÿ[L<ÿ[M<ÿYL<ÿXK<ÿSJ<ÿUK7ÿWNHÿx|¡ÿ ¢ñÿ¨©þÿ¬°þÿ£¦óÿ\85\84Ìÿa\\91ÿA@Mÿ>?4ÿ:A:ÿ<BGÿ<@?ÿ73/ÿQ71ÿ\8eB:ÿ²;4ÿµ4+ÿ <%ÿ»@7ÿ¨?4ÿ¨A4ÿ\9dD6ÿ\90@5ÿ\80@5ÿ\81</ÿ\84:,ÿ\83;*ÿz<+ÿx:+ÿ{:-ÿ\80@6ÿ\86G?ÿ\9aF=ÿ´PKÿªqfÿqk]ÿAA:ÿ:3/ÿ63.ÿ52.ÿ11-ÿ.0-ÿ1.-ÿlfgÿºµµÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÅÀºÿ[K:ÿ[K;ÿYJ;ÿZK;ÿYK>ÿYL;ÿYM>ÿeapÿ\8a\8cÀÿ\9a\9céÿ ¨ùÿ¤òÿ£¥ïÿ\89\8f×ÿdk\9aÿPKYÿQEHÿd\sÿfc{ÿGSRÿ_@9ÿ\96<7ÿ«;,ÿ¥8%ÿ¦=%ÿ¬<'ÿ¨9,ÿ²>3ÿ±C5ÿ¦@.ÿ«?9ÿ\97><ÿ\7f=4ÿw=.ÿx9*ÿ\80<1ÿu:.ÿ\80A6ÿ\87I@ÿ\91LGÿ£\Vÿ¤\8cxÿ\89\9a\81ÿ[fXÿ?=4ÿ63,ÿ23.ÿ/3.ÿ-2/ÿ00.ÿ5..ÿ;./ÿc??ÿ·\92\94ÿãØÞÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôóòÿ\K7ÿ[K8ÿZJ9ÿZJ:ÿ[K<ÿ]M<ÿ]O<ÿYOJÿgc{ÿ\83\84µÿ\92\95Üÿ\97¡âÿ\9c¡ãÿ\9c¨óÿ\98¢Ùÿ\8el\87ÿ\9fM\ÿ»Tcÿ¹j\8bÿ´j\8dÿ NSÿ\9fE7ÿ¨=+ÿ©?*ÿª<(ÿ¸=,ÿ±9+ÿ¨;/ÿ®A2ÿª=,ÿ»>3ÿÃ>=ÿ¦@?ÿw?6ÿ\8b94ÿ´IFÿ¤SMÿ|G:ÿ\86I?ÿ\8aQIÿ\8el_ÿ\91\97\7fÿ\8dª\8cÿw\8cwÿTZHÿ:<0ÿ/1*ÿ.1,ÿ-2.ÿ.3/ÿ21/ÿ2,-ÿF21ÿ\80GAÿ\96gyÿ\8c\85®ÿªªÄÿáßåÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\86ykÿ]L8ÿ\K7ÿ\L8ÿ\K:ÿ]K<ÿ^N<ÿ\O>ÿYLGÿg`vÿ|x±ÿ\88\86Ëÿ\81\86Âÿ\82\84¾ÿ¨\7f²ÿÆg\83ÿÜERÿçAGÿèEMÿÙDLÿÐDJÿÅ@7ÿ¬:%ÿ¯=*ÿ²;)ÿ¾7+ÿÊ:1ÿ·:/ÿ®;,ÿ³?0ÿ»@3ÿÍ;1ÿê79ÿÖ=<ÿº?>ÿÓ>EÿÌOMÿ\8aQDÿlS?ÿx[Hÿ\81pYÿz\97uÿ\82®\8aÿ\7f¤\84ÿf\83eÿJXCÿ57,ÿ-+(ÿ/.,ÿ.0.ÿ01.ÿ01.ÿ2.,ÿU5+ÿ\86STÿ\85|ªÿbg\9fÿPGiÿ}{\87ÿÇÈÈÿõöõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÀº³ÿ_N<ÿ^M;ÿ^M:ÿ]L:ÿ]L;ÿ^M=ÿ^O<ÿ^O;ÿ^NKÿg]\83ÿ\83{¾ÿ\89|µÿvj\9cÿ\92UjÿÜF\ÿæ>Cÿç>?ÿå<<ÿÌ@2ÿÓB<ÿâ>=ÿÇ>2ÿ¸<,ÿ¿;-ÿË;0ÿØ:1ÿÓ:4ÿÆ80ÿÂ;0ÿÃ;/ÿÊ6+ÿÞ4+ÿó.-ÿç83ÿé66ÿ×5/ÿ¬ODÿlaFÿugLÿ\92nVÿ¬j_ÿ¦\8bxÿ\8b¨\87ÿr\9awÿ]\7f\ÿJTCÿ5.,ÿ1**ÿ2,+ÿ0-+ÿ00-ÿ/1/ÿ7-,ÿX@=ÿ\80s\98ÿms¸ÿLAsÿOE_ÿqswÿ\8a\8e\82ÿ\97\97\8fÿÚÙÙÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúúùÿ]N=ÿ_O?ÿ_O=ÿ^N;ÿ_M8ÿ^M:ÿ[O>ÿ]P=ÿ`M=ÿaNVÿog\8cÿ\9a~§ÿ±t¡ÿJXÿÕ<;ÿù7>ÿéC@ÿæ@HÿÑ>@ÿÎD?ÿè?Aÿß:<ÿÇ?6ÿÉ@4ÿÔ<2ÿÛ:1ÿÝ71ÿÜ:5ÿÚ;5ÿ×;2ÿØ;3ÿÝ4+ÿå5-ÿò0*ÿæ4&ÿÚ4#ÿÅ?3ÿ\96bMÿ\89eLÿÇ`Xÿò?RÿçEWÿ¾~tÿ\8f \7fÿz\95pÿf\86eÿGVEÿ1/+ÿ.'*ÿ/)+ÿ0+,ÿ0/+ÿ1+0ÿ=56ÿvs\82ÿ\85\89Éÿ[X ÿC7dÿMK\ÿz\80yÿlo`ÿ\81\7f}ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿzocÿ]O?ÿ_QAÿ_P@ÿ_P;ÿ^N8ÿZOBÿ^USÿhXXÿfPOÿjayÿ\8f\83©ÿÓz\8fÿíNaÿÚ<;ÿâ@8ÿõ??ÿëBKÿÕBDÿÀA:ÿÙB@ÿß>>ÿÍ?8ÿÆC7ÿÁ8+ÿÑ5,ÿÛ4-ÿÝ81ÿâ:4ÿà92ÿà?6ÿì5+ÿó.(ÿõ.)ÿç1&ÿ×5!ÿÑ7'ÿÇL@ÿÅYNÿèVVÿõ<Eÿí9Fÿû8PÿìN^ÿ¿slÿ\93\92uÿk\8biÿER>ÿ-(%ÿ.&(ÿ/),ÿ1*0ÿ1*0ÿ/)(ÿclSÿ\92\9a°ÿ|\87½ÿ^`\89ÿHH]ÿ?DKÿPXNÿXXRÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ²¯¨ÿTI:ÿ]P@ÿ`SCÿ`R@ÿ]O?ÿ_TQÿjgxÿxr\90ÿqj\83ÿoq\96ÿ\80\86Èÿ²\85«ÿ÷klÿøANÿÞAEÿæABÿêAGÿÇ=:ÿ°</ÿÆ@8ÿÐ73ÿÈ?4ÿÁ=/ÿ¼<-ÿÆ6,ÿÚ40ÿÝ:/ÿÝ7,ÿ×3(ÿÕ9*ÿå?1ÿø1-ÿú,)ÿë2)ÿÓ7!ÿÔ6$ÿÒ;/ÿÕF@ÿíEHÿç@DÿÉ>9ÿçCHÿý0Gÿö>UÿåWgÿÅppÿ\92k`ÿPE5ÿ3*$ÿ)*'ÿ)+-ÿ**/ÿ,((ÿHM4ÿ\84\91xÿ\8f¥\9bÿ\98µ«ÿ|\8f\8dÿm\80|ÿp\80wÿ_g[ÿÄÅÁÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿèèçÿFD9ÿQI=ÿ_RAÿaTAÿbWPÿiapÿww\9aÿz|²ÿtv´ÿu{ºÿ\83\8aÎÿ\97\8bÑÿ½x\8cÿîX\ÿòAQÿä>Eÿá@AÿÈ?8ÿ«:*ÿ¾?3ÿØ<7ÿÌB7ÿ½:(ÿ¾:&ÿÄ:)ÿÙ90ÿá70ÿà6+ÿÔ4"ÿÉ5"ÿÌ9&ÿæ;2ÿû13ÿì0-ÿÕ3&ÿÍ8$ÿÑ6(ÿØB<ÿÜIEÿÖ@:ÿ½<0ÿº@4ÿä@Bÿû6Hÿÿ3Tÿø>aÿçRmÿ×Ylÿ¢ITÿX65ÿ*.%ÿ1)+ÿ.'*ÿ41*ÿkuUÿ\8b£tÿ\99½\8bÿ¢Ç¢ÿ\91·\98ÿ\91¯\94ÿ{\8fzÿ\8c\91\82ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTWNÿ=<5ÿVI<ÿ`UDÿibcÿup\8eÿvz¬ÿls´ÿdl¶ÿzzÔÿ\9d\9eÒÿ±®¿ÿ½¨§ÿÏ\81pÿñUVÿñ>FÿÝ:;ÿÄ>3ÿ«;*ÿ·<.ÿÛ<8ÿßB=ÿÄ=-ÿÂ:'ÿÆ9&ÿ×7(ÿç4.ÿê20ÿÚ6,ÿÅ8'ÿÄ8)ÿÏ6*ÿç51ÿí23ÿÛ3/ÿÖ7-ÿÐ:*ÿÔ;0ÿÝPHÿº>2ÿ·;'ÿ±:*ÿÀ@5ÿëBEÿûANÿÿ<Vÿÿ<fÿÿ;oÿñGoÿËJaÿv;=ÿB-(ÿB-)ÿNE6ÿbiNÿz\90gÿ\81£oÿ\90¶\81ÿ\8e¶\85ÿ\8b±\87ÿ\83¡\81ÿ]jOÿö÷õÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\9a\9d\98ÿ-2+ÿA<6ÿSJ<ÿgchÿso\93ÿmk¥ÿbf«ÿjq½ÿ\87\8dÔÿ±±àÿàÞ½ÿîç¥ÿÔ¿\92ÿ¹kSÿÞGEÿç;=ÿÊ?3ÿ®<,ÿ·?2ÿÓ83ÿã:4ÿßK>ÿËB3ÿÈ7(ÿ×5(ÿê7-ÿñ2/ÿþ,3ÿæ2/ÿÏ73ÿØ;6ÿÖ8-ÿÝ8,ÿæ42ÿç24ÿì51ÿÜ9,ÿÝD;ÿØFCÿ½<*ÿº:(ÿÅ@7ÿØGEÿïFJÿúCQÿþ@`ÿü?nÿýCtÿýIpÿùZvÿ\92ILÿJ:-ÿTM3ÿimLÿj\81Wÿn\91^ÿw\9eiÿ}¤oÿ\80§xÿ}\9cxÿ`rXÿÈÌÅÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿááßÿ-1'ÿ/1-ÿ><8ÿVUZÿee\86ÿTS\8bÿ\^¤ÿssÆÿ\8f\8eÞÿ§©àÿÇÇÜÿÞÚÆÿÜÖµÿµ²\92ÿ®m\ÿåQQÿá87ÿÂ:/ÿ¸B8ÿÄB:ÿÒ7-ÿÜ:)ÿâK>ÿÍ:-ÿØ5-ÿé5/ÿé3,ÿì-%ÿö++ÿõ+7ÿ÷*;ÿå1.ÿÇ8$ÿÏ5&ÿß10ÿó+0ÿä3*ÿÖ>0ÿáMJÿÑA;ÿÂ:)ÿÄ=/ÿÐICÿÕGGÿïFKÿýI\ÿþEhÿþHwÿüJuÿüTuÿæXsÿ\80FDÿNH4ÿxuZÿz\89fÿm\89[ÿn\93`ÿm\98hÿu\9esÿy\9awÿh\7fdÿ\86\8d\80ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿZYNÿ45.ÿ34-ÿBE>ÿVXkÿ[[\92ÿeg³ÿy{Ñÿ\88\88Üÿ\94\93Öÿ\9d\9aÔÿ©¤Óÿµ¬Åÿ\98\96\9dÿ\81vnÿºkfÿöWZÿß77ÿÃ;4ÿÁRGÿÉJ>ÿÖ7*ÿã90ÿÙ@3ÿÖ:/ÿì67ÿó17ÿö/:ÿö+4ÿö'5ÿý\1a6ÿó&3ÿ×3,ÿÐ8)ÿÚ7.ÿÓ7-ÿÒ6)ÿÌ7&ÿØJ>ÿÙFFÿÑ@8ÿÁ9,ÿÅD7ÿÈH?ÿÚJFÿñOVÿ÷G`ÿþJqÿþN{ÿþPxÿüRsÿà[rÿ\92fbÿ¢\97\8bÿ¥©¢ÿ\8b\9a\8dÿ\83\96zÿ}\96tÿ\7f\9c\7fÿz\98{ÿj\89gÿ]hTÿ÷÷öÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¥¡\9aÿIE8ÿ??4ÿ?C.ÿMNIÿ\Zvÿqp²ÿ\85\86äÿ\84\85áÿ\86\87Òÿ\87\85Îÿ\8c\86Òÿ\95\8cÊÿ\8b\80¯ÿngqÿ}b]ÿÈsoÿñZYÿâ=;ÿ½<3ÿÁSEÿÌ@5ÿÞ2+ÿâ;1ÿÞ>0ÿë44ÿù6@ÿü"/ÿü$2ÿó)<ÿõ,Mÿ÷2Kÿð>Hÿè49ÿï66ÿå=4ÿÍ?0ÿÆ9'ÿÓ>0ÿßBAÿâLKÿÈ:0ÿÀ<+ÿ¾@/ÿÃB5ÿØMIÿëS[ÿúRkÿüRvÿ÷XzÿüRpÿñVnÿ¿ptÿ¶\9b\92ÿáÛßÿÕÎÞÿÁ½Äÿ¾¼µÿ¼¾´ÿ¡¬¡ÿs\8aqÿYjPÿÐÓÌÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿæåãÿ\SDÿXO@ÿPL9ÿON:ÿSS@ÿig{ÿ\8d\8aÙÿ\8f\8cîÿ\82\82Ðÿ\83\84Íÿ\87\82Öÿ\8c\84Ëÿ\87\82®ÿz_pÿdWOÿ\8cUJÿ×f`ÿö\Yÿâ?9ÿÄE9ÿÐTEÿÒ1(ÿå94ÿâ;/ÿé3+ÿ÷9=ÿøCIÿñ-1ÿð%+ÿï(<ÿø>ZÿûXiÿõGYÿð2>ÿñ-0ÿÝ94ÿÏ;1ÿÏ5+ÿã97ÿèDCÿâLEÿÊ=.ÿ¼;(ÿ¹<+ÿÀC8ÿÒPNÿð\gÿüVpÿüSuÿþVrÿûUhÿùbpÿÄhiÿòÙÓÿúõüÿ÷éúÿûïùÿñèèÿÞÕÛÿ©¬©ÿbu]ÿ\93\9b\8bÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýýüÿyqdÿe[LÿaXHÿ]UDÿ^TCÿa[Oÿxs\92ÿ\8f\8aÑÿ\82~Áÿ\83\82Âÿ\8c\8aÍÿ\8c\83Ãÿ\84} ÿzdlÿc[NÿnWEÿÆYVÿîurÿùrnÿÙIAÿÅ>0ÿÎ<-ÿã@<ÿâA8ÿâ1&ÿí/+ÿð@BÿíEIÿå65ÿà01ÿê=Jÿ÷[fÿïLSÿÖ7<ÿÄ3-ÿÊ;/ÿàFCÿÜ97ÿß85ÿß1.ÿÖ7-ÿÐ<0ÿÁ<-ÿ³;+ÿ±<.ÿ¹?2ÿâ\XÿûdpÿüSoÿú]uÿû^nÿýYgÿÙOXÿØ\9e\99ÿÿþþÿþúÿÿÿûÿÿþüûÿúñõÿÜÔÚÿ\86\91\84ÿlycÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ«¦\9eÿi`Qÿh_Oÿf]Nÿe[Mÿe\Hÿg^Uÿtizÿzq\92ÿup\9aÿ\80|«ÿ\84z ÿ|q\85ÿmb^ÿe\Kÿb_Eÿ¡XNÿßaeÿï\81|ÿòmfÿÇ8,ÿÃ8'ÿÕ?5ÿáGDÿá:3ÿæ0*ÿÛ3*ÿÚAAÿëNTÿêPTÿáEIÿÛ>Cÿß=?ÿË72ÿ£7&ÿ\992\1fÿÈD;ÿÝLHÿÕ=7ÿÒ7+ÿÈ7'ÿÉ8,ÿÐI=ÿµ</ÿ«:,ÿ;,ÿÊNAÿîieÿöhpÿôesÿðouÿógsÿØgkÿ¨gcÿáÇÄÿüúúÿýýþÿþû÷ÿÿûûÿúóöÿÆÄÁÿ\8b\93\85ÿÞáÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâàÝÿi`Qÿi`Qÿi`Qÿh_Pÿi`Pÿi`Kÿh_Pÿmb^ÿg^`ÿ`\dÿkdlÿoa\ÿl\Nÿc\Hÿg]Hÿz[GÿÁXUÿðgiÿðleÿËA4ÿ½:$ÿÉ;*ÿÓ9/ÿÖ90ÿà70ÿÔ8-ÿÆ9-ÿâMLÿôVaÿóZbÿâDHÿè5<ÿÝ69ÿÓIEÿ¿FAÿº@:ÿÄ:7ÿÕD?ÿÇ9+ÿ·9%ÿµ9(ÿÒJ@ÿÈ?5ÿ¹8-ÿ«9+ÿ±>/ÿØ\Sÿìfhÿïdmÿðpqÿùouÿëy\81ÿ\84raÿ\8e~uÿóåæÿûÿÿÿýûùÿÿúøÿþðôÿæÛÚÿÉÈ¿ÿÑÔÎÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿofXÿi`Qÿi`QÿjaRÿjaTÿjaVÿi`Qÿh_Lÿf]Iÿ^XIÿUREÿ_VEÿj\Hÿj^Kÿj^Mÿw^Kÿ\9aUDÿèPPÿçIEÿÒ=0ÿÆ:&ÿÊ:)ÿÕ6+ÿÎ:+ÿÖ8-ÿÖ9.ÿÃ<*ÿÃ=1ÿÑ>@ÿñYcÿù_fÿô08ÿñ0=ÿ÷VbÿódmÿÜRTÿáRQÿÛIEÿÌ=3ÿÄ8*ÿ°9)ÿ¿>4ÿÖ@:ÿØ82ÿÓ92ÿ»9,ÿ¿G>ÿðqtÿôlvÿ÷krÿüioÿýj{ÿ\98\8ezÿQ\BÿÝÈÆÿþýÿÿýýýÿÿûøÿüóòÿèÛÙÿïæÚÿèêâÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¦ \97ÿi`Qÿi`QÿlcTÿkaSÿl`Zÿk`[ÿjaRÿibKÿg`IÿYTBÿMI8ÿZTAÿf_Jÿw_Oÿ\8eYMÿ¢M>ÿÑ;3ÿä52ÿÝ2*ÿ×7&ÿÒ8(ÿÖ4)ÿÌ9*ÿÈ8)ÿÕ:-ÿÇ:*ÿÃ>0ÿÅ;5ÿÕFHÿêW]ÿç?Aÿò2;ÿöERÿûbkÿ÷[cÿáGDÿÛ?<ÿ×C<ÿÙ=7ÿÔ64ÿÌ93ÿÝF>ÿæ40ÿö11ÿä5/ÿÀ8-ÿÞb`ÿúy\81ÿûu}ÿýmvÿüWiÿºmkÿ_sPÿ¿µ¥ÿüùøÿÿþÿÿýþýÿþÿøÿóíèÿïçÙÿø÷èÿþþüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÛÙÕÿiaQÿkbSÿkaSÿjaRÿlbVÿlbVÿlcRÿkbTÿkaTÿg_LÿSP<ÿHI7ÿQSAÿd_Pÿ\9a\Sÿ·G?ÿ½7,ÿÚ3,ÿâ4+ÿÙ7%ÿÑ9&ÿÜ5+ÿÈ7)ÿÁ<*ÿÎA2ÿÐ=/ÿÇ:,ÿÇ:/ÿÉ<4ÿÕLFÿÔE;ÿâ:5ÿî>EÿíDIÿõINÿß73ÿá75ÿÜ@9ÿÝ?8ÿì37ÿö5>ÿé><ÿâ3.ÿû.1ÿ÷/0ÿÜ5,ÿÊF=ÿðuvÿý}\85ÿþs\7fÿþSgÿêReÿ\8a\98rÿ\9dª\85ÿõðçÿÿÿÿÿ÷þúÿïÿñÿüýöÿôñâÿúùâÿüýôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿsm^ÿibRÿjcSÿibRÿjbSÿkbSÿkcQÿldPÿlbVÿlbSÿf^KÿNN=ÿ@F7ÿBI<ÿkSFÿÂLJÿÏ5/ÿÆ9+ÿÜ8.ÿÛ7+ÿÐ:'ÿÕ:+ÿÁ:*ÿ»;)ÿÉ=.ÿÕA5ÿÉ9*ÿÈ9)ÿË8,ÿÏ>3ÿÊ<1ÿÕ3'ÿï-3ÿô-<ÿõ09ÿò53ÿë52ÿß81ÿ×91ÿç64ÿù1<ÿô7;ÿá5/ÿì2.ÿ÷/1ÿï1-ÿÉ6(ÿÖ^Yÿþ\85\8aÿüt\80ÿýXmÿúB]ÿ\97\80cÿ}\97eÿÆÊ«ÿÛçÒÿ×éÖÿÒñÖÿäôÞÿûûíÿþùãÿýûìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\9f\9c\91ÿibRÿkcSÿibRÿibRÿjbSÿkbSÿlcSÿlcTÿnbTÿmcTÿb]LÿII:ÿ:C4ÿAF3ÿ\8aRCÿÞHFÿÇ=/ÿÌ:*ÿÚ8+ÿÕ8*ÿÔ9*ÿÅ;+ÿ´8'ÿÑ<2ÿßE<ÿÁ9*ÿÅ:(ÿË8(ÿÒ9+ÿÖ;/ÿÜ5.ÿö06ÿý*<ÿü'>ÿÿ 9ÿ÷+5ÿè61ÿß:1ÿä95ÿç::ÿë66ÿÞ5.ÿä4,ÿõ00ÿö//ÿ×3'ÿÃI>ÿú\89\8aÿÿx\86ÿýYqÿøC\ÿ©VLÿf|Kÿx\85Zÿ\83\9arÿ\91±\89ÿ\94¹\8dÿ¬Ð¤ÿßéÎÿùïÞÿøðáÿþýûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÖÕÐÿhcSÿhcSÿhcSÿibRÿjbSÿkbSÿkbSÿlcTÿmbSÿpaTÿi`Sÿ\VFÿEA1ÿ8B*ÿiK7ÿ·ZLÿßKFÿÊ:,ÿÐ8(ÿÓ9*ÿÕ8*ÿÐ:+ÿ³:)ÿ³7'ÿÔ?6ÿÃ=/ÿº:)ÿÇ9*ÿÑ5*ÿÚ5,ÿç96ÿô4=ÿö.=ÿõ,<ÿþ%:ÿþ&8ÿï28ÿß;5ÿä95ÿê77ÿé65ÿÜ5-ÿâ6*ÿó0.ÿù/2ÿé1,ÿÄ<0ÿätrÿþz\86ÿÿTpÿü?aÿÁENÿVh<ÿr\86Xÿx\8ebÿn\93`ÿv\9efÿ\8a·{ÿ¦Å\95ÿØÙÂÿïàÕÿõïêÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøø÷ÿro`ÿgdRÿgdRÿhcSÿicSÿkcSÿlcTÿlcTÿlbSÿk_Sÿj`Vÿpk^ÿb\HÿEF-ÿzJ<ÿ¿AAÿàRRÿèKJÿÍ:-ÿÎ:+ÿÑ:)ÿÒ:)ÿ¼<-ÿ\996\1fÿ·=,ÿÐ?3ÿÑD8ÿÎ=3ÿÕ<4ÿà:4ÿé:7ÿï7;ÿî2=ÿì9?ÿð47ÿ÷09ÿï4;ÿÜ:6ÿà;5ÿë65ÿë44ÿá5/ÿÞ7*ÿì2+ÿ÷03ÿö0/ÿÓ8-ÿÈOKÿüz\86ÿüSoÿþ?eÿº@OÿW\9ÿq\95\ÿ\83¡mÿ\80¦oÿ\83«oÿ\86¯pÿ\8a·vÿ\99²\84ÿÐƶÿÞÏÊÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\99\97\8dÿheWÿheUÿgdSÿgdRÿjcSÿlcUÿmdUÿlbRÿf^Tÿ{voÿ\9a\99\94ÿ¨¤\9cÿ\85\82qÿcR>ÿ\91G@ÿ½HHÿìcfÿÛKEÿÍ>4ÿÐ=2ÿÒ</ÿÇ<0ÿ\9d7#ÿ\9c:"ÿ½7)ÿÓ:1ÿà:9ÿá<;ÿè::ÿé98ÿè96ÿð@CÿìMOÿîRMÿì<;ÿæ76ÿÞ75ÿß:6ÿê65ÿï47ÿâ5/ÿÛ7(ÿâ7'ÿî4.ÿô11ÿà5-ÿÀ:4ÿüw\82ÿýSpÿü?cÿ¼?Pÿ^Q:ÿg\86Qÿ{ eÿ~¦kÿ|¥fÿ\82§jÿ\83²nÿ\85²qÿ¨±\90ÿö¯ÿ÷ôôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÐÏÊÿheVÿheVÿheWÿheWÿidUÿlcVÿmdUÿlcSÿlf[ÿ\91\92\90ÿÑÓÓÿö÷ùÿßÝÙÿ\91\8b}ÿ=>,ÿi?5ÿ£HEÿËMLÿÐE@ÿÓE?ÿ×E>ÿÖB;ÿÄ?8ÿ¨=,ÿ¶<,ÿÒ:2ÿé:=ÿæ8<ÿí7;ÿë79ÿÖ;5ÿÍ>5ÿÙLFÿÒGBÿÞ=9ÿà83ÿß85ÿá88ÿé89ÿò69ÿç63ÿÖ7*ÿÚ8&ÿã6'ÿî5,ÿæ4*ÿ×>8ÿí^fÿþNmÿÿ<dÿÀHYÿKC.ÿYnHÿw\98`ÿv\9e`ÿv\9e_ÿ{¡dÿ~¨iÿ\7f°gÿ\91±yÿ¶¹¤ÿãààÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷÷öÿheVÿheVÿheVÿheVÿheVÿjdYÿmeWÿkeRÿibVÿz}}ÿÐÖÙÿÿÿÿÿÿÿÿÿøéáÿ\9e\90}ÿBH2ÿ<=.ÿ^@5ÿ¤E@ÿÍB=ÿÐD=ÿÚGDÿäGKÿÐHBÿÎF<ÿßGAÿäDBÿÖ?=ÿÊ85ÿÕ78ÿÏ62ÿ±9(ÿ³:*ÿÈ;1ÿÝ:8ÿâ85ÿã84ÿæ78ÿé8<ÿî7;ÿë78ÿØ8/ÿÐ9)ÿÕ8&ÿ×9&ÿÛ9&ÿÛ=5ÿñU`ÿþJjÿü=fÿ±IUÿND2ÿBJ0ÿl\85Wÿv\99\ÿp\98Wÿv\9d]ÿz£bÿ{©^ÿ\86±jÿ\98³\86ÿ¬¶¬ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\92\90\85ÿheVÿheVÿifWÿhfVÿieWÿmdYÿjfSÿmldÿ\8c\91\95ÿÀÊÏÿñüüÿüÿûÿþþôÿíðÕÿ\8c\93sÿAJ3ÿ<91ÿQ;3ÿ©EDÿÓA@ÿÖC@ÿÝAEÿàFGÿæHGÿìBCÿãEBÿÂB;ÿ¡?1ÿ£>3ÿ¤:/ÿ¢;*ÿ¥<(ÿ¸:*ÿÜ<5ÿì79ÿç78ÿç76ÿë8;ÿì6=ÿì6:ÿ×;4ÿÃ9)ÿÆ;)ÿÇ<$ÿÈ<$ÿ×?5ÿúUfÿÿAfÿó<cÿ¦?KÿQE5ÿIF2ÿS`=ÿm\8aQÿh\92Lÿp\98Tÿw\9f\ÿy¥Zÿ\7f¬_ÿ\87«pÿ|\93uÿíðíÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÈÈÂÿfdTÿhfVÿifWÿifWÿjeVÿlc[ÿlfWÿprcÿ¢¨ªÿÝâçÿúûûÿýÿûÿúüïÿùüìÿàäÇÿ\82\86eÿB@.ÿ882ÿYCAÿÇjjÿÖJGÿÝDBÿßCDÿàDDÿäB@ÿäB?ÿÎ@=ÿ\9e>0ÿ\8aC2ÿ\80B0ÿ\86>,ÿ\96>+ÿ£=(ÿÀ:-ÿå96ÿð67ÿè85ÿå:4ÿè88ÿê8;ÿÚ>8ÿ½;,ÿ´<)ÿ¸<)ÿ¸:$ÿÒA9ÿõH\ÿÿ;fÿôAgÿ\816Cÿ34'ÿ=>-ÿBG*ÿ\qBÿf\8cGÿi\92Lÿq\99Xÿt\9eUÿs\9fSÿ{¢^ÿv\91cÿ½Ç¸ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ`gRÿefUÿhfWÿifWÿjeVÿmd[ÿmgZÿhjTÿ\81\89\87ÿÝäéÿÿÿÿÿþþüÿ÷ùñÿøúòÿüüëÿÓ̱ÿcaLÿKKAÿ~xvÿɳ®ÿÝ\8f\8aÿÜ<=ÿàACÿÝDDÿÚFBÿÛD>ÿÕB=ÿ¬<3ÿ\8a?1ÿ\85<1ÿ\80;1ÿ\84;.ÿ\8a<,ÿ\9d:*ÿ¾:0ÿæ<6ÿë<6ÿä=4ÿá=9ÿá<<ÿÙ=;ÿ»=1ÿ§;)ÿ¥;(ÿ¢7$ÿÀ=6ÿþL_ÿù=bÿÊ?Yÿk;@ÿ/0,ÿ/4\1fÿRP-ÿn|Rÿc|Jÿb\8aDÿj\92Oÿk\92Pÿf\90Jÿa\88EÿVr=ÿx\8biÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÆÉÁÿ\8c\93\83ÿgkWÿigXÿjfWÿldYÿmf[ÿhkUÿkvlÿºÅËÿþÿÿÿþþüÿôõíÿæêÝÿòõãÿááÄÿ\7f\81eÿ^gWÿ¨§ ÿêáÞÿùïéÿç¤ ÿÓMMÿ×ABÿÝBBÿÖD?ÿÔE=ÿÈA:ÿ\96<0ÿ\80<1ÿ\84:3ÿ\82;1ÿ~;1ÿ\82;.ÿ\929+ÿ°;/ÿÑ=3ÿÜB7ÿÓA9ÿÊ=:ÿÃ?8ÿ:-ÿ\9c;)ÿ\94:&ÿ\8f7%ÿ³F>ÿòRaÿæG]ÿ®KTÿL=2ÿ41,ÿ@?,ÿpzJÿ¡µ\80ÿw\90cÿ_\85Aÿg\8eHÿk\8fLÿd\8bHÿ\\81EÿVr@ÿPh;ÿúûúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòóñÿ¼¼´ÿ\88\83xÿlgYÿlf[ÿiiWÿeq_ÿ\98§¨ÿéîñÿþÿýÿúûòÿèíÛÿèîÔÿääÊÿ¹¸ ÿ\94\98\89ÿ»Áºÿõòðÿÿýüÿÿÿþÿè¹²ÿÊYRÿÑ@?ÿÖA?ÿÑD<ÿÙB:ÿ²?5ÿ\84=-ÿ\81<0ÿ\86:/ÿ\82;.ÿ~;.ÿ{;,ÿ\7f:+ÿ\9e:.ÿ´=/ÿµ;/ÿ«90ÿ\9d8,ÿ\968)ÿ\8f:(ÿ\8c:'ÿ\847$ÿ\9bC9ÿÉVYÿÂSWÿ\91[PÿB?+ÿ9>&ÿWK5ÿ\87\9beÿªÊ\8aÿ\90¯xÿc\87Gÿk\91Iÿo\94Pÿi\8dHÿd\86Jÿa\7fHÿ_xEÿ¿É¶ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿåäâÿ¯§ÿwviÿemZÿ\82\92\8fÿØáæÿþÿþÿÿÿöÿóøåÿåëÎÿæäËÿÚÒÄÿÖÎÈÿáàÝÿ÷÷öÿÿÿýÿýÿþÿýúöÿáºÿ±J>ÿÆ<8ÿÓ@>ÿØA<ÿÇB:ÿ\94<.ÿ\80=-ÿ\83:,ÿ\84:+ÿ\80:,ÿ~:-ÿ|:.ÿ\809.ÿ\8b8-ÿ\998)ÿ\938*ÿ\8b9,ÿ\86;*ÿ\83;)ÿ\7f;(ÿ|6#ÿ\82<-ÿ¨SKÿ UOÿ\90^Pÿhd?ÿ\l;ÿo\90Vÿ\8d£iÿ\9a¼~ÿ\83\9dpÿWu@ÿg\8cDÿp\96Pÿk\8fJÿi\8bLÿe\84Jÿe\81Hÿ\8a sÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÖØÓÿ¬µ²ÿÈÒÙÿøüûÿýþöÿúüëÿäéÎÿØØ¿ÿäÛÔÿôèêÿÿúÿÿýýýÿÿÿþÿÿÿýÿþþýÿÿÿÿÿí×ÑÿÀ`WÿÈA;ÿÏB=ÿÍC=ÿ©?6ÿ\86</ÿ\80<,ÿ\81:+ÿ\7f9,ÿ~:-ÿ~:/ÿ|:0ÿ{80ÿ\809-ÿ\83:,ÿ\7f<,ÿ\809+ÿ}8*ÿx:+ÿv7'ÿ\83=.ÿ\93NBÿ\93WKÿ\90]Sÿ\8fqZÿ\81\97`ÿ\86¢cÿp\88Sÿr\81WÿUbEÿEU3ÿa\7f?ÿk\93Iÿg\8dHÿf\89Iÿf\88Lÿf\86Hÿg\89Gÿõ÷óÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýýÿùûôÿïïÝÿááËÿÌÉ´ÿØÐËÿ÷ïóÿÿûþÿÿÿýÿÿÿýÿþþüÿþþüÿþþýÿþüüÿäžÿ»\OÿÃ?6ÿÊE<ÿ®?9ÿ\8c<2ÿ\80=/ÿ\7f;-ÿ}9.ÿ}9/ÿ}:0ÿ}:0ÿz90ÿy8/ÿy9/ÿx9/ÿy8-ÿx4)ÿy6,ÿr5)ÿ}</ÿ\90K>ÿ\92TIÿ\96XRÿ\8e^RÿrzUÿL\=ÿ9H,ÿ@F4ÿ79-ÿ9@.ÿ[n>ÿj\90Fÿc\8cFÿg\89Fÿj\8dNÿg\8cKÿi\8eIÿËØ¿ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþüÿðîåÿÓ̽ÿËÁ¹ÿðèíÿÿÿþÿþÿüÿþþüÿþþüÿþþüÿþþüÿÿýûÿûÿýÿèÝÒÿ¹n]ÿ¼C5ÿ¯E6ÿ\8dA6ÿ\81>4ÿ~<0ÿ}:.ÿ|9/ÿ|;1ÿ{;2ÿw:3ÿt8/ÿt8.ÿu9/ÿt9.ÿr6,ÿp5*ÿn3(ÿu<1ÿ\86P@ÿ\8dRGÿ\9aTPÿ\96^Xÿi_Dÿ2=)ÿ08/ÿ;>6ÿ76/ÿ8:/ÿJX9ÿj\8aHÿh\91Hÿj\8dKÿl\90Oÿk\92Oÿh\92Hÿ\98¶\81ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõóòÿóîñÿþúÿÿýþýÿþþüÿþþüÿþþüÿþþüÿûÿýÿüþÿÿûþÿÿðäÞÿÇ\7flÿ¹>6ÿ¡=9ÿ\85?8ÿ\82<3ÿ~:1ÿ{9/ÿ|90ÿz:3ÿt;2ÿn9/ÿm7-ÿo8-ÿp8,ÿo6-ÿm3*ÿk3(ÿp9.ÿ\82MDÿ\8dSJÿ\99QMÿ\8e\TÿofMÿZjAÿGT<ÿLRBÿA@/ÿ9:.ÿ<F1ÿi\85Kÿr\98Nÿl\94Pÿl\93Mÿn\97Mÿn\99Nÿz¦\ÿöùôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿþþþÿþþþÿÿþüÿþþüÿþþýÿýþþÿþúþÿÿüýÿðãÕÿ¹u^ÿ\9f=1ÿ\8e:5ÿxA=ÿu>7ÿw:1ÿv7.ÿv80ÿs8/ÿj8/ÿi8.ÿh7-ÿj8-ÿl7/ÿk4,ÿh3)ÿg3'ÿ}D;ÿ\92SNÿ\92UNÿ\84^Oÿ^`EÿPf>ÿ[oDÿP^>ÿEI/ÿ9:)ÿ8>.ÿ\rDÿt\98Pÿp\99Rÿo\97Nÿn\99Iÿt¤Pÿu¤UÿÓâËÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿþüÿÿýùÿþýýÿûÿúÿûÿøÿþÿýÿÿþòÿÑ«\96ÿ\9bUEÿ~9-ÿpA6ÿq?6ÿq>4ÿp;1ÿo6-ÿk7/ÿh7/ÿf7,ÿf7-ÿh7.ÿj6.ÿf3*ÿ`.$ÿp8/ÿ\93SNÿ\89[Rÿy^Oÿ_cIÿUkEÿTi@ÿBT.ÿ6@*ÿ:;.ÿ8;/ÿK\:ÿp\91Nÿs\9cPÿp\9cLÿs\9eNÿx¦Vÿu¤Wÿ\9a¸\89ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿþþÿÿýýÿýþûÿýüøÿþýýÿøóíÿ͵¦ÿ\84U=ÿl=+ÿo;3ÿs?9ÿp?7ÿj<3ÿl81ÿk61ÿg5/ÿf6.ÿg7.ÿi60ÿg5-ÿ_0&ÿe5+ÿ\81MGÿwXLÿYSCÿIO<ÿ?L5ÿ<K0ÿ?K0ÿ8=+ÿ:<1ÿ7:0ÿ:C.ÿf\82Gÿu\9dPÿq\9eNÿv£Tÿ{¦^ÿm\98Rÿi\91Uÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿýûùÿ÷îêÿþûüÿÿÿþÿüûôÿÀª\98ÿ\86^Oÿj8/ÿo?6ÿn?7ÿn<5ÿp73ÿl60ÿh70ÿh81ÿk71ÿk9/ÿg:0ÿi=4ÿkIAÿVF=ÿ>@1ÿ4>/ÿ06-ÿ37.ÿ8?/ÿ@G4ÿ8>0ÿ6;1ÿ7:,ÿTe;ÿu\99Pÿp\9eQÿv¦Wÿt\9eYÿf\8fNÿa\89KÿÔßÎÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþÿþÿþÿýÿÿÿú÷ðÿçÜÊÿ¥\8eyÿfF4ÿg@3ÿi>3ÿk<5ÿj;3ÿe<1ÿc<2ÿgB6ÿgC4ÿfF4ÿ{eTÿl\Oÿ782ÿ36,ÿ19,ÿ4;0ÿ573ÿ05.ÿ4=0ÿ9F4ÿ3<0ÿ592ÿCJ2ÿf\7fIÿu\9fXÿv£Zÿi\94Rÿ^\86Iÿd\8bKÿ\9b³\8eÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿóÿãßÆÿi\BÿXG.ÿ_I3ÿ`F6ÿ_D6ÿ]D4ÿ_G7ÿQ=,ÿ[M9ÿ`O7ÿodMÿnmZÿ8>3ÿ06-ÿ27-ÿ46+ÿ38,ÿ280ÿ/9-ÿ5C2ÿ3A0ÿ.4/ÿ8:-ÿRc9ÿu\9aWÿt\9dZÿb\8aLÿ]\85Gÿe\8dJÿb\86Jÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýýúÿ½ºÿqkSÿVN2ÿWN5ÿTO9ÿSL7ÿ\WAÿNL6ÿFI/ÿVT8ÿ``CÿjpYÿ=F6ÿ-4*ÿ07-ÿ16+ÿ16+ÿ/7,ÿ09*ÿ0;,ÿ6C2ÿ4=0ÿ12)ÿ>H.ÿo\90Uÿq\9aWÿ^\81Gÿ\\81Eÿb\89Jÿ_\85IÿÙâÕÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßÞÙÿ \9e\8fÿ_]FÿMO6ÿOT;ÿS]Aÿ>G,ÿAG*ÿceGÿejPÿ4@,ÿ16.ÿ17-ÿ17-ÿ05,ÿ/3-ÿ/3-ÿ/5-ÿ07-ÿ8A2ÿ49+ÿ6<*ÿbzRÿm\94XÿWxAÿZ}Dÿ`\83Jÿ_\83Jÿ\9c²\92ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÍÎÇÿ\8a\8e}ÿEN.ÿGO/ÿHO0ÿUV8ÿdcIÿBF3ÿ5;1ÿ4:1ÿ39/ÿ17-ÿ.3,ÿ-2-ÿ.3-ÿ.1,ÿ/6.ÿ5>1ÿ38*ÿO^Eÿj\8b_ÿVxCÿUtAÿ]}Iÿ_\82Iÿi\87Zÿûüúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþÿ½¿³ÿ\88\8esÿ`cDÿ]\BÿWS>ÿ?B4ÿ8>4ÿ7>4ÿ6<1ÿ28/ÿ.3-ÿ.3-ÿ,1+ÿ,2,ÿ.8/ÿ1>2ÿ@M;ÿYpRÿHi=ÿNm=ÿUrBÿ_~JÿXvHÿÞäÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿððíÿ±±¦ÿtr^ÿQO8ÿCC5ÿ:>5ÿ8>4ÿ8>5ÿ7;6ÿ382ÿ.3-ÿ*/)ÿ+2,ÿ+5-ÿ2>/ÿ>K6ÿBT8ÿKf>ÿLh<ÿYwGÿ[xJÿ\9c¨\96ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßÞÚÿ\9d\9a\90ÿSRFÿ;?5ÿ9@6ÿ:@9ÿ9>8ÿ5:4ÿ/4.ÿ,1+ÿ+2+ÿ+5,ÿ0:,ÿ4@-ÿ@R7ÿG_;ÿUoGÿ\xOÿZjUÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÈÉÆÿ\7f\84}ÿ8C5ÿ:A8ÿ:?8ÿ9>8ÿ372ÿ+1+ÿ*/*ÿ-3,ÿ6?4ÿ:E3ÿ@P7ÿRfFÿ\rRÿ>P=ÿÝàÝÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýýýÿµ¸´ÿmskÿ:B7ÿ:@8ÿ6;6ÿ.3/ÿ,0,ÿ.1.ÿ9@7ÿ7B1ÿAM7ÿ[jSÿHVEÿ\93\99\94ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿëìëÿ¤¨¢ÿ]e]ÿ9B8ÿ270ÿ+//ÿ.40ÿ8D5ÿ5B-ÿHVAÿKWIÿEMGÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÙÛÙÿ\91\95\8fÿELFÿ2>.ÿ6H/ÿ7K2ÿ:K4ÿAN>ÿ6@7ÿàâàÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÆÊÄÿ\88\98|ÿGb<ÿ:L6ÿ;L5ÿ7E5ÿ\9d¢\9cÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýýüÿµ¼´ÿq\7fmÿFZ@ÿU`Sÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿìîëÿ ¦\9eÿÿÿÿÿ
\ No newline at end of file
/*
Initialize image colormap.
*/
- if (AcquireImageColormap(image,2) == MagickFalse)
+ if (AcquireImageColormap(image,2,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image_info->ping != MagickFalse)
{
/*
Convert image to a bi-level image.
*/
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
quantum_info=AcquireQuantumInfo(image_info,image);
for (y=0; y < (ssize_t) image->rows; y++)
{
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Reading colormap of %.20g colors",(double) image->colors);
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
bmp_colormap=(unsigned char *) AcquireQuantumMemory((size_t)
image->colors,4*sizeof(*bmp_colormap));
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"\n");
}
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
polarity = 0;
if (image->storage_class == PseudoClass) {
polarity=(Quantum) (GetPixelPacketIntensity(&image->colormap[0]) >=
/*
Format caption.
*/
- property=InterpretImageProperties(image_info,image,image_info->filename);
+ property=InterpretImageProperties(image_info,image,image_info->filename,
+ exception);
(void) SetImageProperty(image,"caption",property);
property=DestroyString(property);
caption=ConstantString(GetImageProperty(image,"caption"));
status;
if (image->clip_mask == (Image *) NULL)
- (void) ClipImage(image);
+ (void) ClipImage(image,exception);
if (image->clip_mask == (Image *) NULL)
ThrowWriterException(CoderError,"ImageDoesNotHaveAClipMask");
clip_image=CloneImage(image->clip_mask,0,0,MagickTrue,exception);
if (clip_image == (Image *) NULL)
return(MagickFalse);
- (void) SetImageType(clip_image,TrueColorType);
+ (void) SetImageType(clip_image,TrueColorType,exception);
(void) CopyMagickString(clip_image->filename,image->filename,MaxTextExtent);
write_info=CloneImageInfo(image_info);
(void) SetImageInfo(write_info,1,exception);
if(PalHeader.MaxIndex<1) goto ErasePalette;
image->colors=PalHeader.MaxIndex+1;
- if (AcquireImageColormap(image,image->colors) == MagickFalse) goto NoMemory;
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse) goto NoMemory;
if(PalHeader.MaxRed==0) PalHeader.MaxRed=(unsigned int) QuantumRange; /*avoid division by 0*/
if(PalHeader.MaxGreen==0) PalHeader.MaxGreen=(unsigned int) QuantumRange;
{
image->colors=256;
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
{
NoMemory:
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
one=1;
if (colors == 0)
colors=one << depth;
- if (AcquireImageColormap(image,colors) == MagickFalse)
+ if (AcquireImageColormap(image,colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (redmap != (int *) NULL)
for (i=0; i < (ssize_t) colors; i++)
/*
Read DIB raster colormap.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
length=(size_t) image->colors;
dib_colormap=(unsigned char *) AcquireQuantumMemory(length,
image->storage_class = PseudoClass;
image->depth = 8UL; /* i only support that? */
image->colors= 2;
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,
"MemoryAllocationFailed");
} else {
#if 0
/* palette */
- if (AcquireImageColormap(image,2) == MagickFalse)
+ if (AcquireImageColormap(image,2,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
/*
Monochrome colormap. mmc: this the default!
GetQuantizeInfo(&quantize_info);
quantize_info.dither=IsPaletteImage(write_image,exception) == MagickFalse
? MagickTrue : MagickFalse;
- (void) QuantizeImage(&quantize_info,write_image);
+ (void) QuantizeImage(&quantize_info,write_image,exception);
}
write_info->compression=NoCompression;
ept_info.tiff=(unsigned char *) ImageToBlob(write_info,write_image,
if (image->rows == 0)
image->rows=3508;
image->depth=8;
- if (AcquireImageColormap(image,2) == MagickFalse)
+ if (AcquireImageColormap(image,2,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
/*
Monochrome colormap.
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
- status=HuffmanDecodeImage(image);
+ status=HuffmanDecodeImage(image,exception);
if (status == MagickFalse)
ThrowReaderException(CorruptImageError,"UnableToReadImageData");
if (EOFBlob(image) != MagickFalse)
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(image,RGBColorspace);
- status=HuffmanEncodeImage(write_info,image,image);
+ status=HuffmanEncodeImage(write_info,image,image,exception);
if (GetNextImageInList(image) == (Image *) NULL)
break;
image=SyncNextImageInList(image);
return(PopLZWStack(lzw_info->stack));
}
-static MagickBooleanType DecodeImage(Image *image,const ssize_t opacity)
+static MagickBooleanType DecodeImage(Image *image,const ssize_t opacity,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
int
c;
if (lzw_info == (LZWInfo *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
- exception=(&image->exception);
pass=0;
offset=0;
for (y=0; y < (ssize_t) image->rows; y++)
return(y);
}
-static MagickBooleanType PingGIFImage(Image *image)
+static MagickBooleanType PingGIFImage(Image *image,ExceptionInfo *exception)
{
unsigned char
buffer[256],
/*
Inititialize colormap.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
{
global_colormap=(unsigned char *) RelinquishMagickMemory(
global_colormap);
Decode image.
*/
if (image_info->ping != MagickFalse)
- status=PingGIFImage(image);
+ status=PingGIFImage(image,exception);
else
- status=DecodeImage(image,opacity);
+ status=DecodeImage(image,opacity,exception);
if ((image_info->ping == MagickFalse) && (status == MagickFalse))
{
global_colormap=(unsigned char *) RelinquishMagickMemory(
if (IsImageOpaque(image,exception) != MagickFalse)
{
if ((image->storage_class == DirectClass) || (image->colors > 256))
- (void) SetImageType(image,PaletteType);
+ (void) SetImageType(image,PaletteType,exception);
}
else
{
Identify transparent colormap index.
*/
if ((image->storage_class == DirectClass) || (image->colors > 256))
- (void) SetImageType(image,PaletteBilevelMatteType);
+ (void) SetImageType(image,PaletteBilevelMatteType,exception);
for (i=0; i < (ssize_t) image->colors; i++)
if (image->colormap[i].alpha != OpaqueAlpha)
{
}
if (opacity == -1)
{
- (void) SetImageType(image,PaletteBilevelMatteType);
+ (void) SetImageType(image,PaletteBilevelMatteType,exception);
for (i=0; i < (ssize_t) image->colors; i++)
if (image->colormap[i].alpha != OpaqueAlpha)
{
*/
one=1;
number_colors=one << icon_info.bits_per_pixel;
- if (AcquireImageColormap(image,number_colors) == MagickFalse)
+ if (AcquireImageColormap(image,number_colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
icon_colormap=(unsigned char *) AcquireQuantumMemory((size_t)
image->colors,4UL*sizeof(*icon_colormap));
char
*text;
- text=InterpretImageProperties(image_info,image,format);
+ text=InterpretImageProperties(image_info,image,format,exception);
if (text != (char *) NULL)
{
(void) WriteBlobString(image,text);
image->columns=jbg_dec_getwidth(&jbig_info);
image->rows=jbg_dec_getheight(&jbig_info);
image->compression=JBIG2Compression;
- if (AcquireImageColormap(image,2) == MagickFalse)
+ if (AcquireImageColormap(image,2,exception) == MagickFalse)
{
buffer=(unsigned char *) RelinquishMagickMemory(buffer);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
/*
Convert pixels to a bitmap.
*/
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
typedef struct _ErrorManager
{
+ ExceptionInfo
+ *exception;
+
Image
*image;
ErrorManager
*error_manager;
+ ExceptionInfo
+ *exception;
+
Image
*image;
*message='\0';
error_manager=(ErrorManager *) jpeg_info->client_data;
+ exception=error_manager->exception;
image=error_manager->image;
if (level < 0)
{
ErrorManager
*error_manager;
+ ExceptionInfo
+ *exception;
+
Image
*image;
Determine length of comment.
*/
error_manager=(ErrorManager *) jpeg_info->client_data;
+ exception=error_manager->exception;
image=error_manager->image;
length=(size_t) ((size_t) GetCharacter(jpeg_info) << 8);
length+=GetCharacter(jpeg_info);
ErrorManager
*error_manager;
+ ExceptionInfo
+ *exception;
+
Image
*image;
(void) GetCharacter(jpeg_info); /* markers */
length-=14;
error_manager=(ErrorManager *) jpeg_info->client_data;
+ exception=error_manager->exception;
image=error_manager->image;
profile=BlobToStringInfo((const void *) NULL,length);
if (profile == (StringInfo *) NULL)
ErrorManager
*error_manager;
+ ExceptionInfo
+ *exception;
+
Image
*image;
if (length == 0)
return(MagickTrue);
error_manager=(ErrorManager *) jpeg_info->client_data;
+ exception=error_manager->exception;
image=error_manager->image;
profile=BlobToStringInfo((const void *) NULL,length);
if (profile == (StringInfo *) NULL)
ErrorManager
*error_manager;
+ ExceptionInfo
+ *exception;
+
Image
*image;
marker=jpeg_info->unread_marker-JPEG_APP0;
(void) FormatLocaleString(name,MaxTextExtent,"APP%d",marker);
error_manager=(ErrorManager *) jpeg_info->client_data;
+ exception=error_manager->exception;
image=error_manager->image;
profile=BlobToStringInfo((const void *) NULL,length);
if (profile == (StringInfo *) NULL)
jpeg_info.err->emit_message=(void (*)(j_common_ptr,int)) JPEGWarningHandler;
jpeg_info.err->error_exit=(void (*)(j_common_ptr)) JPEGErrorHandler;
jpeg_pixels=(JSAMPLE *) NULL;
+ error_manager.exception=exception;
error_manager.image=image;
if (setjmp(error_manager.error_recovery) != 0)
{
if (jpeg_info.out_color_space == JCS_CMYK)
image->colorspace=CMYKColorspace;
if ((image_info->colors != 0) && (image_info->colors <= 256))
- if (AcquireImageColormap(image,image_info->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image_info->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if ((jpeg_info.output_components == 1) &&
(jpeg_info.quantize_colors == MagickFalse))
colors;
colors=(size_t) GetQuantumRange(image->depth)+1;
- if (AcquireImageColormap(image,colors) == MagickFalse)
+ if (AcquireImageColormap(image,colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
if (image->debug != MagickFalse)
jpeg_info.err=jpeg_std_error(&jpeg_error);
jpeg_info.err->emit_message=(void (*)(j_common_ptr,int)) JPEGWarningHandler;
jpeg_info.err->error_exit=(void (*)(j_common_ptr)) JPEGErrorHandler;
+ error_manager.exception=exception;
error_manager.image=image;
jpeg_pixels=(JSAMPLE *) NULL;
if (setjmp(error_manager.error_recovery) != 0)
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
(void) ResetImagePage(image,"0x0+0+0");
- property=InterpretImageProperties(image_info,image,image_info->filename);
+ property=InterpretImageProperties(image_info,image,image_info->filename,
+ exception);
(void) SetImageProperty(image,"label",property);
property=DestroyString(property);
label=GetImageProperty(image,"label");
image->columns=576;
image->rows=720;
image->depth=1;
- if (AcquireImageColormap(image,2) == MagickFalse)
+ if (AcquireImageColormap(image,2,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image_info->ping != MagickFalse)
{
*/
image->storage_class=PseudoClass;
status=AcquireImageColormap(image,(size_t)
- (image->offset != 0 ? image->offset : 256));
+ (image->offset != 0 ? image->offset : 256),exception);
if (status == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
depth=GetImageQuantumDepth(image,MagickTrue);
Allocate colormap.
*/
if (IsPaletteImage(image,exception) == MagickFalse)
- (void) SetImageType(image,PaletteType);
+ (void) SetImageType(image,PaletteType,exception);
depth=GetImageQuantumDepth(image,MagickTrue);
packet_size=(size_t) (depth/8);
pixels=(unsigned char *) AcquireQuantumMemory(image->columns,packet_size*
{
if(image->colors>256) image->colors = 256;
- if (!AcquireImageColormap(image, image->colors))
+ if (AcquireImageColormap(image, image->colors,exception) == MagickFalse)
{
NoMemory:ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");}
}
matte_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
if (matte_image == (Image *) NULL)
return(MagickFalse);
- (void) SetImageType(matte_image,TrueColorMatteType);
+ (void) SetImageType(matte_image,TrueColorMatteType,exception);
matte_image->matte=MagickFalse;
/*
Convert image to matte pixels.
/*
Create image colormap.
*/
- status=AcquireImageColormap(image,colors != 0 ? colors : 256);
+ status=AcquireImageColormap(image,colors != 0 ? colors : 256,exception);
if (status == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (colors != 0)
Initialize image colormap.
*/
image->depth=1;
- if (AcquireImageColormap(image,2) == MagickFalse)
+ if (AcquireImageColormap(image,2,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image_info->ping != MagickFalse)
{
/*
Convert image to a bi-level image.
*/
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
/*
Create image colormap.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image->colors != 0)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'R':
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
if ((attribute != (const char *) NULL) &&
(LocaleCompare(value,value) == 0))
{
- SetImageType(composite_image,TrueColorMatteType);
+ SetImageType(composite_image,TrueColorMatteType,
+ &exception);
(void) CompositeImage(composite_image,
CopyOpacityCompositeOp,msl_info->image[j],0,0);
break;
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
}
}
}
- (void) CycleColormapImage(msl_info->image[n],display);
+ (void) CycleColormapImage(msl_info->image[n],display,&exception);
break;
}
ThrowMSLException(OptionError,"UnrecognizedElement",(const char *) tag);
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
affine.tx;
draw_info->affine.ty=affine.rx*current.tx+affine.sy*current.ty+
affine.ty;
- (void) DrawImage(msl_info->image[n],draw_info);
+ (void) DrawImage(msl_info->image[n],draw_info,&exception);
draw_info=DestroyDrawInfo(draw_info);
break;
}
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'C':
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
quantize_info=AcquireQuantizeInfo(msl_info->image_info[n]);
quantize_info->dither=dither;
(void) RemapImages(quantize_info,msl_info->image[n],
- affinity_image);
+ affinity_image,&exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
affinity_image=DestroyImage(affinity_image);
break;
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
if (*keyword == '+')
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
}
}
}
- (void) QuantizeImage(&quantize_info,msl_info->image[n]);
+ (void) QuantizeImage(&quantize_info,msl_info->image[n],&exception);
break;
}
if (LocaleCompare((const char *) tag,"query-font-metrics") == 0)
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'F':
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'G':
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'b':
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'G':
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'D':
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
}
}
(void) SegmentImage(msl_info->image[n],colorspace,verbose,
- geometry_info.rho,geometry_info.sigma);
+ geometry_info.rho,geometry_info.sigma,&exception);
break;
}
else if (LocaleCompare((const char *) tag, "set") == 0)
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'C':
property=GetImageProperty(msl_info->attributes[j],"id");
if (LocaleCompare(property,value) == 0)
{
- SetImageMask(msl_info->image[n],msl_info->image[j]);
+ SetImageMask(msl_info->image[n],msl_info->image[j],
+ &exception);
break;
}
}
property=GetImageProperty(msl_info->attributes[j],"id");
if (LocaleCompare(property,value) == 0)
{
- SetImageClipMask(msl_info->image[n],msl_info->image[j]);
+ SetImageClipMask(msl_info->image[n],msl_info->image[j],
+ &exception);
break;
}
}
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'R':
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'G':
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
}
}
}
- (void) SignatureImage(msl_info->image[n]);
+ (void) SignatureImage(msl_info->image[n],&exception);
break;
}
if (LocaleCompare((const char *) tag,"solarize") == 0)
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'I':
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'I':
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
attribute=InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]);
+ msl_info->attributes[n],(const char *) attributes[i],
+ &exception);
CloneString(&value,attribute);
switch (*keyword)
{
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'T':
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'C':
{
keyword=(const char *) attributes[i++];
CloneString(&value,InterpretImageProperties(msl_info->image_info[n],
- msl_info->attributes[n],(const char *) attributes[i]));
+ msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
case 'F':
draw_info->primitive[GetBlobSize(image)]='\0';
}
}
- (void) DrawImage(image,draw_info);
+ (void) DrawImage(image,draw_info,exception);
draw_info=DestroyDrawInfo(draw_info);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
depth=(unsigned char) ReadBlobByte(image);
if (depth != 1)
ThrowReaderException(CoderError,"OnlyLevelZerofilesSupported");
- if (AcquireImageColormap(image,2) == MagickFalse)
+ if (AcquireImageColormap(image,2,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image_info->ping != MagickFalse)
{
/*
Convert image to a bi-level image.
*/
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
info=0;
if ((image->columns >= 256) || (image->rows >= 256))
SetBit(info,4,1);
*/
one=1;
if ((bits_per_pixel < 16) &&
- (AcquireImageColormap(image,one << bits_per_pixel) == MagickFalse))
+ (AcquireImageColormap(image,one << bits_per_pixel,exception) == MagickFalse))
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
GetPixelInfo(image,&transpix);
if (bits_per_pixel == 16) /* Direct Color */
if (bits_per_pixel < 8)
{
(void) TransformImageColorspace(image,GRAYColorspace);
- (void) SetImageType(image,PaletteType);
- (void) SortColormapByIntensity(image);
+ (void) SetImageType(image,PaletteType,exception);
+ (void) SortColormapByIntensity(image,exception);
}
if ((image->storage_class == PseudoClass) && (image->colors > 256))
(void) SetImageStorageClass(image,DirectClass,exception);
{
quantize_info->dither=IsPaletteImage(image,exception);
quantize_info->number_colors=image->colors;
- (void) QuantizeImage(quantize_info,image);
+ (void) QuantizeImage(quantize_info,image,exception);
(void) WriteBlobMSBShort(image,(unsigned short) image->colors);
for (count = 0; count < image->colors; count++)
{
exception);
(void) TransformImageColorspace(affinity_image,
affinity_image->colorspace);
- (void) RemapImage(quantize_info,image,affinity_image);
+ (void) RemapImage(quantize_info,image,affinity_image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
%
*/
static MagickBooleanType DecodeImage(Image *image,unsigned char *luma,
- unsigned char *chroma1,unsigned char *chroma2)
+ unsigned char *chroma1,unsigned char *chroma2,ExceptionInfo *exception)
{
#define IsSync ((sum & 0xffffff00UL) == 0xfffffe00UL)
#define PCDGetBits(n) \
image->rows=1024;
for (i=0; i < (4*0x800); i++)
(void) ReadBlobByte(image);
- status=DecodeImage(image,luma,chroma1,chroma2);
+ status=DecodeImage(image,luma,chroma1,chroma2,exception);
if ((scene >= 5) && status)
{
/*
image->rows=2048;
offset=TellBlob(image)/0x800+12;
offset=SeekBlob(image,offset*0x800,SEEK_SET);
- status=DecodeImage(image,luma,chroma1,chroma2);
+ status=DecodeImage(image,luma,chroma1,chroma2,exception);
if ((scene >= 6) && (status != MagickFalse))
{
/*
((pcx_info.bits_per_pixel*pcx_info.planes) == 1))
image->colors=(size_t) MagickMin(one << (1UL*
(pcx_info.bits_per_pixel*pcx_info.planes)),256UL);
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if ((pcx_info.bits_per_pixel >= 8) && (pcx_info.planes != 1))
image->storage_class=DirectClass;
image->storage_class=PseudoClass;
bits_per_pixel=pdb_image.type == 0 ? 2UL : pdb_image.type == 2 ? 4UL : 1UL;
one=1;
- if (AcquireImageColormap(image,one << bits_per_pixel) == MagickFalse)
+ if (AcquireImageColormap(image,one << bits_per_pixel,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image_info->ping != MagickFalse)
{
}
static MagickBooleanType Huffman2DEncodeImage(const ImageInfo *image_info,
- Image *image,Image *inject_image)
+ Image *image,Image *inject_image,ExceptionInfo *exception)
{
Image
*group4_image;
write_info=CloneImageInfo(image_info);
(void) CopyMagickString(write_info->filename,"GROUP4:",MaxTextExtent);
(void) CopyMagickString(write_info->magick,"GROUP4",MaxTextExtent);
- group4_image=CloneImage(inject_image,0,0,MagickTrue,&image->exception);
+ group4_image=CloneImage(inject_image,0,0,MagickTrue,exception);
if (group4_image == (Image *) NULL)
return(MagickFalse);
group4=(unsigned char *) ImageToBlob(write_info,group4_image,&length,
- &image->exception);
+ exception);
group4_image=DestroyImage(group4_image);
if (group4 == (unsigned char *) NULL)
return(MagickFalse);
{
if (LocaleCompare(CCITTParam,"0") == 0)
{
- (void) HuffmanEncodeImage(image_info,image,image);
+ (void) HuffmanEncodeImage(image_info,image,image,exception);
break;
}
- (void) Huffman2DEncodeImage(image_info,image,image);
+ (void) Huffman2DEncodeImage(image_info,image,image,exception);
break;
}
case JPEGCompression:
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
if (compression == ZipCompression)
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
else
#endif
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
if (compression == ZipCompression)
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
else
#endif
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
if (compression == ZipCompression)
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
else
#endif
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
{
if (LocaleCompare(CCITTParam,"0") == 0)
{
- (void) HuffmanEncodeImage(image_info,image,tile_image);
+ (void) HuffmanEncodeImage(image_info,image,tile_image,
+ exception);
break;
}
- (void) Huffman2DEncodeImage(image_info,image,tile_image);
+ (void) Huffman2DEncodeImage(image_info,image,tile_image,exception);
break;
}
case JPEGCompression:
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
if (compression == ZipCompression)
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
else
#endif
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
if (compression == ZipCompression)
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
else
#endif
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
if (compression == ZipCompression)
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
else
#endif
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
if (compression == ZipCompression)
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
else
#endif
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
flags=1L*ReadBlobMSBShort(image);
tile_image->colors=1UL*ReadBlobMSBShort(image)+1;
}
- status=AcquireImageColormap(tile_image,tile_image->colors);
+ status=AcquireImageColormap(tile_image,tile_image->colors,
+ exception);
if (status == MagickFalse)
{
tile_image=DestroyImage(tile_image);
image->columns=width;
image->rows=height;
if (bits_per_pixel == 8)
- if (AcquireImageColormap(image,256) == MagickFalse)
+ if (AcquireImageColormap(image,256,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
if (image->scene >= (image_info->scene+image_info->number_scenes-1))
/*
Initialize image colormap.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
if (LocaleCompare(image_info->magick,"PNG24") == 0)
{
- (void) SetImageType(image,TrueColorType);
+ (void) SetImageType(image,TrueColorType,exception);
image->matte=MagickFalse;
}
if (LocaleCompare(image_info->magick,"PNG32") == 0)
- (void) SetImageType(image,TrueColorMatteType);
+ (void) SetImageType(image,TrueColorMatteType,exception);
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
/* Write one PNG image */
static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
- const ImageInfo *IMimage_info,Image *IMimage)
+ const ImageInfo *IMimage_info,Image *IMimage,ExceptionInfo *exception)
{
Image
*image;
image->colors = image_colors;
- if (AcquireImageColormap(image,image_colors) ==
+ if (AcquireImageColormap(image,image_colors,exception) ==
MagickFalse)
ThrowWriterException(ResourceLimitError,
"MemoryAllocationFailed");
image->depth = 8;
if (image->matte == MagickTrue)
- (void) SetImageType(image,TrueColorMatteType);
+ (void) SetImageType(image,TrueColorMatteType,exception);
else
- (void) SetImageType(image,TrueColorType);
+ (void) SetImageType(image,TrueColorType,exception);
(void) SyncImage(image);
}
image->depth = 8;
if (image->matte == MagickTrue)
- (void) SetImageType(image,TrueColorMatteType);
+ (void) SetImageType(image,TrueColorMatteType,exception);
else
- (void) SetImageType(image,TrueColorType);
+ (void) SetImageType(image,TrueColorType,exception);
(void) SyncImage(image);
}
mng_info->need_blob = MagickTrue;
- status=WriteOnePNGImage(mng_info,image_info,image);
+ status=WriteOnePNGImage(mng_info,image_info,image,exception);
MngInfoFreeStruct(mng_info,&have_mng_structure);
/* Write one JNG image */
static MagickBooleanType WriteOneJNGImage(MngInfo *mng_info,
- const ImageInfo *image_info,Image *image)
+ const ImageInfo *image_info,Image *image,ExceptionInfo *exception)
{
Image
*jpeg_image;
jpeg_image_info->quality=jng_quality;
jpeg_image_info->type=GrayscaleType;
- (void) SetImageType(jpeg_image,GrayscaleType);
+ (void) SetImageType(jpeg_image,GrayscaleType,exception);
(void) AcquireUniqueFilename(jpeg_image->filename);
(void) FormatLocaleString(jpeg_image_info->filename,MaxTextExtent,
"%s",jpeg_image->filename);
(void) WriteBlob(image,8,(const unsigned char *) "\213JNG\r\n\032\n");
- status=WriteOneJNGImage(mng_info,image_info,image);
+ status=WriteOneJNGImage(mng_info,image_info,image,exception);
(void) CloseBlob(image);
(void) CatchImageException(image);
/* To do: specify the desired alpha compression method. */
write_info=CloneImageInfo(image_info);
write_info->compression=UndefinedCompression;
- status=WriteOneJNGImage(mng_info,write_info,image);
+ status=WriteOneJNGImage(mng_info,write_info,image,exception);
write_info=DestroyImageInfo(write_info);
}
else
mng_info->ping_exclude_zCCP=MagickTrue;
mng_info->ping_exclude_zTXt=MagickTrue;
- status=WriteOnePNGImage(mng_info,image_info,image);
+ status=WriteOnePNGImage(mng_info,image_info,image,exception);
}
if (status == MagickFalse)
*/
static MagickBooleanType Huffman2DEncodeImage(const ImageInfo *image_info,
- Image *image,Image *inject_image)
+ Image *image,Image *inject_image,ExceptionInfo *exception)
{
Image
*group4_image;
write_info=CloneImageInfo(image_info);
(void) CopyMagickString(write_info->filename,"GROUP4:",MaxTextExtent);
(void) CopyMagickString(write_info->magick,"GROUP4",MaxTextExtent);
- group4_image=CloneImage(inject_image,0,0,MagickTrue,&image->exception);
+ group4_image=CloneImage(inject_image,0,0,MagickTrue,exception);
if (group4_image == (Image *) NULL)
return(MagickFalse);
group4=(unsigned char *) ImageToBlob(write_info,group4_image,&length,
- &image->exception);
+ exception);
group4_image=DestroyImage(group4_image);
if (group4 == (unsigned char *) NULL)
return(MagickFalse);
{
if (LocaleCompare(CCITTParam,"0") == 0)
{
- (void) HuffmanEncodeImage(image_info,image,image);
+ (void) HuffmanEncodeImage(image_info,image,image,exception);
break;
}
- (void) Huffman2DEncodeImage(image_info,image,image);
+ (void) Huffman2DEncodeImage(image_info,image,image,exception);
break;
}
case JPEGCompression:
}
length=(size_t) (q-pixels);
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
}
length=(size_t) (q-pixels);
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
if (status == MagickFalse)
{
(void) CloseBlob(image);
}
length=(size_t) (q-pixels);
if (compression == LZWCompression)
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
else
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
{
*/
static MagickBooleanType Huffman2DEncodeImage(const ImageInfo *image_info,
- Image *image,Image *inject_image)
+ Image *image,Image *inject_image,ExceptionInfo *exception)
{
Image
*group4_image;
write_info=CloneImageInfo(image_info);
(void) CopyMagickString(write_info->filename,"GROUP4:",MaxTextExtent);
(void) CopyMagickString(write_info->magick,"GROUP4",MaxTextExtent);
- group4_image=CloneImage(inject_image,0,0,MagickTrue,&image->exception);
+ group4_image=CloneImage(inject_image,0,0,MagickTrue,exception);
if (group4_image == (Image *) NULL)
return(MagickFalse);
group4=(unsigned char *) ImageToBlob(write_info,group4_image,&length,
- &image->exception);
+ exception);
group4_image=DestroyImage(group4_image);
if (group4 == (unsigned char *) NULL)
return(MagickFalse);
}
static MagickBooleanType SerializeImage(const ImageInfo *image_info,
- Image *image,unsigned char **pixels,size_t *length)
+ Image *image,unsigned char **pixels,size_t *length,ExceptionInfo *exception)
{
MagickBooleanType
status;
}
static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
- Image *image,unsigned char **pixels,size_t *length)
+ Image *image,unsigned char **pixels,size_t *length,ExceptionInfo *exception)
{
MagickBooleanType
status;
q=(*pixels);
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if (pack == 1)
}
static MagickBooleanType SerializeImageIndexes(const ImageInfo *image_info,
- Image *image,unsigned char **pixels,size_t *length)
+ Image *image,unsigned char **pixels,size_t *length,ExceptionInfo *exception)
{
MagickBooleanType
status;
q=(*pixels);
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
}
static MagickBooleanType WritePS3MaskImage(const ImageInfo *image_info,
- Image *image,const CompressionType compression)
+ Image *image,const CompressionType compression,ExceptionInfo *exception)
{
ChannelType
channel_mask;
mask_image=DestroyImage(mask_image);
return(MagickFalse);
}
- (void) SetImageType(mask_image,BilevelType);
- (void) SetImageType(mask_image,PaletteType);
+ (void) SetImageType(mask_image,BilevelType,exception);
+ (void) SetImageType(mask_image,PaletteType,exception);
mask_image->matte=MagickFalse;
pixels=(unsigned char *) NULL;
length=0;
case NoCompression:
default:
{
- status=SerializeImageChannel(image_info,mask_image,&pixels,&length);
+ status=SerializeImageChannel(image_info,mask_image,&pixels,&length,
+ exception);
if (status == MagickFalse)
break;
Ascii85Initialize(image);
{
if ((compression == FaxCompression) ||
(LocaleCompare(CCITTParam,"0") == 0))
- status=HuffmanEncodeImage(image_info,image,mask_image);
+ status=HuffmanEncodeImage(image_info,image,mask_image,exception);
else
- status=Huffman2DEncodeImage(image_info,image,mask_image);
+ status=Huffman2DEncodeImage(image_info,image,mask_image,exception);
break;
}
case LZWCompression:
{
- status=SerializeImageChannel(image_info,mask_image,&pixels,&length);
+ status=SerializeImageChannel(image_info,mask_image,&pixels,&length,
+ exception);
if (status == MagickFalse)
break;
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
break;
}
case RLECompression:
{
- status=SerializeImageChannel(image_info,mask_image,&pixels,&length);
+ status=SerializeImageChannel(image_info,mask_image,&pixels,&length,
+ exception);
if (status == MagickFalse)
break;
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
break;
}
case ZipCompression:
{
- status=SerializeImageChannel(image_info,mask_image,&pixels,&length);
+ status=SerializeImageChannel(image_info,mask_image,&pixels,&length,
+ exception);
if (status == MagickFalse)
break;
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
break;
}
Image mask.
*/
if ((image->matte != MagickFalse) &&
- (WritePS3MaskImage(image_info,image,compression) == MagickFalse))
+ (WritePS3MaskImage(image_info,image,compression,exception) == MagickFalse))
{
(void) CloseBlob(image);
return(MagickFalse);
(compression == Group4Compression))
{
if (LocaleCompare(CCITTParam,"0") == 0)
- status=HuffmanEncodeImage(image_info,image,image);
+ status=HuffmanEncodeImage(image_info,image,image,exception);
else
- status=Huffman2DEncodeImage(image_info,image,image);
+ status=Huffman2DEncodeImage(image_info,image,image,exception);
}
else
{
- status=SerializeImageChannel(image_info,image,&pixels,&length);
+ status=SerializeImageChannel(image_info,image,&pixels,&length,
+ exception);
if (status == MagickFalse)
{
(void) CloseBlob(image);
}
case LZWCompression:
{
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
break;
}
case RLECompression:
{
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
break;
}
case ZipCompression:
{
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
break;
}
}
/*
Stream based compressions.
*/
- status=SerializeImage(image_info,image,&pixels,&length);
+ status=SerializeImage(image_info,image,&pixels,&length,exception);
if (status == MagickFalse)
{
(void) CloseBlob(image);
}
case RLECompression:
{
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
break;
}
case LZWCompression:
{
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
break;
}
case ZipCompression:
{
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
break;
}
}
}
Ascii85Flush(image);
}
- status=SerializeImageIndexes(image_info,image,&pixels,&length);
+ status=SerializeImageIndexes(image_info,image,&pixels,&length,
+ exception);
if (status == MagickFalse)
{
(void) CloseBlob(image);
}
case RLECompression:
{
- status=PackbitsEncodeImage(image,length,pixels);
+ status=PackbitsEncodeImage(image,length,pixels,exception);
break;
}
case LZWCompression:
{
- status=LZWEncodeImage(image,length,pixels);
+ status=LZWEncodeImage(image,length,pixels,exception);
break;
}
case ZipCompression:
{
- status=ZLIBEncodeImage(image,length,pixels);
+ status=ZLIBEncodeImage(image,length,pixels,exception);
break;
}
}
if ((psd_info.mode == BitmapMode) || (psd_info.mode == GrayscaleMode) ||
(psd_info.mode == DuotoneMode))
{
- if (AcquireImageColormap(image,256) == MagickFalse)
+ if (AcquireImageColormap(image,256,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
image->matte=psd_info.channels >= 2 ? MagickTrue : MagickFalse;
if (image->debug != MagickFalse)
/*
Read PSD raster colormap.
*/
- if (AcquireImageColormap(image,(size_t) (length/3)) == MagickFalse)
+ if (AcquireImageColormap(image,(size_t) (length/3),exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (i=0; i < (ssize_t) image->colors; i++)
image->colormap[i].red=ScaleCharToQuantum((unsigned char)
}
static size_t PSDPackbitsEncodeImage(Image *image,const size_t length,
- const unsigned char *pixels,unsigned char *compact_pixels)
+ const unsigned char *pixels,unsigned char *compact_pixels,
+ ExceptionInfo *exception)
{
int
count;
static void WritePackbitsLength(const PSDInfo *psd_info,
const ImageInfo *image_info,Image *image,Image *next_image,
- unsigned char *compact_pixels,const QuantumType quantum_type)
+ unsigned char *compact_pixels,const QuantumType quantum_type,
+ ExceptionInfo *exception)
{
QuantumInfo
*quantum_info;
break;
length=ExportQuantumPixels(next_image,(CacheView *) NULL,quantum_info,
quantum_type,pixels,&image->exception);
- length=PSDPackbitsEncodeImage(image,length,pixels,compact_pixels);
+ length=PSDPackbitsEncodeImage(image,length,pixels,compact_pixels,
+ exception);
(void) SetPSDOffset(psd_info,image,length);
}
quantum_info=DestroyQuantumInfo(quantum_info);
static void WriteOneChannel(const PSDInfo *psd_info,const ImageInfo *image_info,
Image *image,Image *next_image,unsigned char *compact_pixels,
- const QuantumType quantum_type,const MagickBooleanType compression_flag)
+ const QuantumType quantum_type,const MagickBooleanType compression_flag,
+ ExceptionInfo *exception)
{
int
y;
(void) WriteBlob(image,length,pixels);
else
{
- length=PSDPackbitsEncodeImage(image,length,pixels,compact_pixels);
+ length=PSDPackbitsEncodeImage(image,length,pixels,compact_pixels,
+ exception);
(void) WriteBlob(image,length,compact_pixels);
}
}
static MagickBooleanType WriteImageChannels(const PSDInfo *psd_info,
const ImageInfo *image_info,Image *image,Image *next_image,
- const MagickBooleanType separate)
+ const MagickBooleanType separate,ExceptionInfo *exception)
{
int
i;
*/
(void) WriteBlobMSBShort(image,1);
WritePackbitsLength(psd_info,image_info,image,next_image,
- compact_pixels,GrayQuantum);
+ compact_pixels,GrayQuantum,exception);
if (next_image->matte != MagickFalse)
WritePackbitsLength(psd_info,image_info,image,next_image,
- compact_pixels,AlphaQuantum);
+ compact_pixels,AlphaQuantum,exception);
}
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
GrayQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
- MagickFalse);
+ MagickFalse,exception);
if (next_image->matte != MagickFalse)
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
AlphaQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
- MagickFalse);
+ MagickFalse,exception);
(void) SetImageProgress(image,SaveImagesTag,0,1);
}
else
*/
(void) WriteBlobMSBShort(image,1);
WritePackbitsLength(psd_info,image_info,image,next_image,
- compact_pixels,IndexQuantum);
+ compact_pixels,IndexQuantum,exception);
if (next_image->matte != MagickFalse)
WritePackbitsLength(psd_info,image_info,image,next_image,
- compact_pixels,AlphaQuantum);
+ compact_pixels,AlphaQuantum,exception);
}
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
IndexQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
- MagickFalse);
+ MagickFalse,exception);
if (next_image->matte != MagickFalse)
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
AlphaQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
- MagickFalse);
+ MagickFalse,exception);
(void) SetImageProgress(image,SaveImagesTag,0,1);
}
else
*/
(void) WriteBlobMSBShort(image,1);
WritePackbitsLength(psd_info,image_info,image,next_image,
- compact_pixels,RedQuantum);
+ compact_pixels,RedQuantum,exception);
WritePackbitsLength(psd_info,image_info,image,next_image,
- compact_pixels,GreenQuantum);
+ compact_pixels,GreenQuantum,exception);
WritePackbitsLength(psd_info,image_info,image,next_image,
- compact_pixels,BlueQuantum);
+ compact_pixels,BlueQuantum,exception);
if (next_image->colorspace == CMYKColorspace)
WritePackbitsLength(psd_info,image_info,image,next_image,
- compact_pixels,BlackQuantum);
+ compact_pixels,BlackQuantum,exception);
if (next_image->matte != MagickFalse)
WritePackbitsLength(psd_info,image_info,image,next_image,
- compact_pixels,AlphaQuantum);
+ compact_pixels,AlphaQuantum,exception);
}
(void) SetImageProgress(image,SaveImagesTag,0,6);
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
RedQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
- MagickFalse);
+ MagickFalse,exception);
(void) SetImageProgress(image,SaveImagesTag,1,6);
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
GreenQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
- MagickFalse);
+ MagickFalse,exception);
(void) SetImageProgress(image,SaveImagesTag,2,6);
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
BlueQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
- MagickFalse);
+ MagickFalse,exception);
(void) SetImageProgress(image,SaveImagesTag,3,6);
if (next_image->colorspace == CMYKColorspace)
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
BlackQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
- MagickFalse);
+ MagickFalse,exception);
(void) SetImageProgress(image,SaveImagesTag,4,6);
if (next_image->matte != MagickFalse)
WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
AlphaQuantum,(i++ == 0) || (separate != MagickFalse) ? MagickTrue :
- MagickFalse);
+ MagickFalse,exception);
(void) SetImageProgress(image,SaveImagesTag,5,6);
if (next_image->colorspace == CMYKColorspace)
(void) NegateImage(next_image,MagickFalse,&next_image->exception);
while (next_image != NULL)
{
status=WriteImageChannels(&psd_info,image_info,image,next_image,
- MagickTrue);
+ MagickTrue,exception);
next_image=GetNextImageInList(next_image);
}
(void) WriteBlobMSBLong(image,0); /* user mask data */
/*
Write composite image.
*/
- status=WriteImageChannels(&psd_info,image_info,image,image,MagickFalse);
+ status=WriteImageChannels(&psd_info,image_info,image,image,MagickFalse,
+ exception);
(void) CloseBlob(image);
return(status);
}
*/
if (number_colormaps == 0)
map_length=256;
- if (AcquireImageColormap(image,map_length) == MagickFalse)
+ if (AcquireImageColormap(image,map_length,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
p=colormap;
if (number_colormaps == 1)
/*
Create grayscale map.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
/*
Convert SGI image to PseudoClass pixel packets.
if (watermark == (Image *) NULL)
return((Image *) NULL);
watermark->depth=MAGICKCORE_QUANTUM_DEPTH;
- if (AcquireImageColormap(image,MaxColormapSize) == MagickFalse)
+ if (AcquireImageColormap(image,MaxColormapSize,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image_info->ping != MagickFalse)
{
/*
Create linear color ramp.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
break;
/*
Read SUN raster colormap.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
sun_colormap=(unsigned char *) AcquireQuantumMemory(image->colors,
sizeof(*sun_colormap));
/*
Convert PseudoClass image to a SUN monochrome image.
*/
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
one=1;
image->colors=one << tga_info.bits_per_pixel;
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
}
/*
Read TGA raster colormap.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (i=0; i < (ssize_t) image->colors; i++)
{
if (thumbnail_image == (Image *) NULL)
return(MagickFalse);
(void) SetImageType(thumbnail_image,thumbnail_image->matte == MagickFalse ?
- TrueColorType : TrueColorMatteType);
+ TrueColorType : TrueColorMatteType,exception);
(void) CopyMagickString(thumbnail_image->filename,image->filename,
MaxTextExtent);
write_info=CloneImageInfo(image_info);
}
static MagickBooleanType ReadProfile(Image *image,const char *name,
- unsigned char *datum,ssize_t length)
+ unsigned char *datum,ssize_t length,ExceptionInfo *exception)
{
MagickBooleanType
status;
"`%s'",module);
}
-static void TIFFGetProfiles(TIFF *tiff,Image *image)
+static void TIFFGetProfiles(TIFF *tiff,Image *image,ExceptionInfo *exception)
{
uint32
length;
#if defined(TIFFTAG_ICCPROFILE)
length=0;
if (TIFFGetField(tiff,TIFFTAG_ICCPROFILE,&length,&profile) == 1)
- (void) ReadProfile(image,"icc",profile,(ssize_t) length);
+ (void) ReadProfile(image,"icc",profile,(ssize_t) length,exception);
#endif
#if defined(TIFFTAG_PHOTOSHOP)
length=0;
if (TIFFGetField(tiff,TIFFTAG_PHOTOSHOP,&length,&profile) == 1)
- (void) ReadProfile(image,"8bim",profile,(ssize_t) length);
+ (void) ReadProfile(image,"8bim",profile,(ssize_t) length,exception);
#endif
#if defined(TIFFTAG_RICHTIFFIPTC)
length=0;
{
if (TIFFIsByteSwapped(tiff) != 0)
TIFFSwabArrayOfLong((uint32 *) profile,(size_t) length);
- (void) ReadProfile(image,"iptc",profile,4L*length);
+ (void) ReadProfile(image,"iptc",profile,4L*length,exception);
}
#endif
#if defined(TIFFTAG_XMLPACKET)
length=0;
if (TIFFGetField(tiff,TIFFTAG_XMLPACKET,&length,&profile) == 1)
- (void) ReadProfile(image,"xmp",profile,(ssize_t) length);
+ (void) ReadProfile(image,"xmp",profile,(ssize_t) length,exception);
#endif
length=0;
if (TIFFGetField(tiff,37724,&length,&profile) == 1)
- (void) ReadProfile(image,"tiff:37724",profile,(ssize_t) length);
+ (void) ReadProfile(image,"tiff:37724",profile,(ssize_t) length,exception);
}
static void TIFFGetProperties(TIFF *tiff,Image *image)
if ((option != (const char *) NULL) &&
(IsMagickTrue(option) != MagickFalse))
TIFFGetEXIFProperties(tiff,image);
- TIFFGetProfiles(tiff,image);
+ TIFFGetProfiles(tiff,image,exception);
/*
Allocate memory for the image and pixel buffer.
*/
colors;
colors=(size_t) GetQuantumRange(bits_per_sample)+1;
- if (AcquireImageColormap(image,colors) == MagickFalse)
+ if (AcquireImageColormap(image,colors,exception) == MagickFalse)
{
TIFFClose(tiff);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
(void) FormatLocaleString(huffman_image->filename,MaxTextExtent,"tiff:%s",
filename);
- (void) SetImageType(huffman_image,BilevelType);
+ (void) SetImageType(huffman_image,BilevelType,exception);
write_info=CloneImageInfo((ImageInfo *) NULL);
SetImageInfoFile(write_info,file);
write_info->compression=Group4Compression;
*/
if ((image_info->type != UndefinedType) &&
(image_info->type != OptimizeType))
- (void) SetImageType(image,image_info->type);
+ (void) SetImageType(image,image_info->type,exception);
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
case FaxCompression:
case Group4Compression:
{
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
break;
}
case JPEGCompression:
height=ReadBlobLSBShort(image);
image->columns=width;
image->rows=height;
- if (AcquireImageColormap(image,pixel_mode == 1 ? 256UL : 16UL) == MagickFalse)
+ if (AcquireImageColormap(image,pixel_mode == 1 ? 256UL : 16UL,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
tim_colormap=(unsigned char *) AcquireQuantumMemory(image->colors,
2UL*sizeof(*tim_colormap));
i+=6;
}
ConcatenateString(&draw_info->primitive,"pop graphic-context");
- (void) DrawImage(image,draw_info);
+ (void) DrawImage(image,draw_info,exception);
/*
Relinquish resources.
*/
}
}
}
- (void) SetImageType(image,PaletteType);
+ (void) SetImageType(image,PaletteType,exception);
colors=image->colors;
if (transparent != MagickFalse)
{
if ((image->columns == 0) || (image->rows == 0))
ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");
image->depth=8;
- if (AcquireImageColormap(image,256) == MagickFalse)
+ if (AcquireImageColormap(image,256,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image_info->ping != MagickFalse)
{
CatchException(exception);
if (next_image == (Image *) NULL)
break;
- label=InterpretImageProperties(image_info,next_image,DefaultTileLabel);
+ label=InterpretImageProperties(image_info,next_image,DefaultTileLabel,
+ exception);
(void) SetImageProperty(next_image,"label",label);
label=DestroyString(label);
if (image_info->debug != MagickFalse)
image->colors=image->depth <= 8 ? 256UL : 65536UL;
if (viff_info.data_storage_type == VFF_TYP_BIT)
image->colors=2;
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
break;
default: bytes_per_pixel=1; break;
}
image->colors=viff_info.map_columns;
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
viff_colormap=(unsigned char *) AcquireQuantumMemory(image->colors,
viff_info.map_rows*bytes_per_pixel*sizeof(*viff_colormap));
/*
Convert bitmap scanline.
*/
- (void) SetImageType(image,BilevelType);
- (void) SetImageType(image,PaletteType);
+ (void) SetImageType(image,BilevelType,exception);
+ (void) SetImageType(image,PaletteType,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
/*
Convert PseudoClass image to a VIFF monochrome image.
*/
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (DiscardBlobBytes(image,image->offset) == MagickFalse)
ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
image->filename);
- if (AcquireImageColormap(image,2) == MagickFalse)
+ if (AcquireImageColormap(image,2,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image_info->ping != MagickFalse)
{
/*
Convert image to a bi-level image.
*/
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
(void) WriteBlobMSBShort(image,0);
WBMPWriteInteger(image,image->columns);
WBMPWriteInteger(image,image->rows);
*/
#if defined(MAGICKCORE_WEBP_DELEGATE)
static MagickBooleanType
- WriteWEBPImage(const ImageInfo *,Image *);
+ WriteWEBPImage(const ImageInfo *,Image *,ExceptionInfo *);
#endif
\f
#if defined(MAGICKCORE_WEBP_DELEGATE)
}
static MagickBooleanType WriteWEBPImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
int
webp_status;
WPG_Palette.NumOfEntries=ReadBlobLSBShort(image);
image->colors=WPG_Palette.NumOfEntries;
- if (!AcquireImageColormap(image,image->colors))
+ if (!AcquireImageColormap(image,image->colors,exception))
goto NoMemory;
for (i=WPG_Palette.StartIndex;
i < (int)WPG_Palette.NumOfEntries; i++)
if ((image->colors == 0) && (bpp != 24))
{
image->colors=one << bpp;
- if (!AcquireImageColormap(image,image->colors))
+ if (!AcquireImageColormap(image,image->colors,exception))
{
NoMemory:
ThrowReaderException(ResourceLimitError,
WPG_Palette.NumOfEntries=ReadBlobLSBShort(image);
image->colors=WPG_Palette.NumOfEntries;
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,
"MemoryAllocationFailed");
for (i=WPG_Palette.StartIndex;
one=1;
image->colors=one << bpp;
- if (!AcquireImageColormap(image,image->colors))
+ if (!AcquireImageColormap(image,image->colors,exception))
goto NoMemory;
}
else
/*
Initialize image structure.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
/*
Initialize colormap.
/*
Convert MIFF to X bitmap pixels.
*/
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
bit=0;
byte=0;
count=0;
}
static MagickBooleanType load_tile(Image *image,Image *tile_image,
- XCFDocInfo *inDocInfo,XCFLayerInfo *inLayerInfo,size_t data_length)
+ XCFDocInfo *inDocInfo,XCFLayerInfo *inLayerInfo,size_t data_length,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
ssize_t
y;
if (count != (ssize_t) data_length)
ThrowBinaryException(CorruptImageError,"NotEnoughPixelData",
image->filename);
- exception=(&image->exception);
for (y=0; y < (ssize_t) tile_image->rows; y++)
{
q=QueueAuthenticPixels(tile_image,0,y,tile_image->columns,1,exception);
}
static MagickBooleanType load_tile_rle(Image *image,Image *tile_image,
- XCFDocInfo *inDocInfo,XCFLayerInfo *inLayerInfo,size_t data_length)
+ XCFDocInfo *inDocInfo,XCFLayerInfo *inLayerInfo,size_t data_length,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
MagickOffsetType
size;
switch (inDocInfo->compression)
{
case COMPRESS_NONE:
- if (load_tile(image,tile_image,inDocInfo,inLayerInfo,(size_t) (offset2-offset)) == 0)
+ if (load_tile(image,tile_image,inDocInfo,inLayerInfo,(size_t) (offset2-offset),exception) == 0)
status=MagickTrue;
break;
case COMPRESS_RLE:
if (load_tile_rle (image,tile_image,inDocInfo,inLayerInfo,
- (int) (offset2-offset)) == 0)
+ (int) (offset2-offset),exception) == 0)
status=MagickTrue;
break;
case COMPRESS_ZLIB:
}
static MagickBooleanType ReadOneLayer(Image* image,XCFDocInfo* inDocInfo,
- XCFLayerInfo *outLayer )
+ XCFLayerInfo *outLayer, ExceptionInfo *exception )
{
MagickOffsetType
offset;
/* seek to the layer offset */
offset=SeekBlob(image,offset,SEEK_SET);
/* read in the layer */
- layer_ok=ReadOneLayer(image,&doc_info,&layer_info[current_layer]);
+ layer_ok=ReadOneLayer(image,&doc_info,&layer_info[current_layer],
+ exception);
if (layer_ok == MagickFalse)
{
int j;
*/
xpm_colors=NewSplayTree(CompareXPMColor,RelinquishMagickMemory,
(void *(*)(void *)) NULL);
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
/*
Read image colormap.
if ((picon == (Image *) NULL) || (affinity_image == (Image *) NULL))
return(MagickFalse);
quantize_info=AcquireQuantizeInfo(image_info);
- status=RemapImage(quantize_info,picon,affinity_image);
+ status=RemapImage(quantize_info,picon,affinity_image,exception);
quantize_info=DestroyQuantizeInfo(quantize_info);
affinity_image=DestroyImage(affinity_image);
transparent=MagickFalse;
if (picon->storage_class == PseudoClass)
{
- (void) CompressImageColormap(picon);
+ (void) CompressImageColormap(picon,exception);
if (picon->matte != MagickFalse)
transparent=MagickTrue;
}
break;
}
}
- (void) SetImageType(picon,PaletteType);
+ (void) SetImageType(picon,PaletteType,exception);
}
colors=picon->colors;
if (transparent != MagickFalse)
if (image->matte == MagickFalse)
{
if ((image->storage_class == DirectClass) || (image->colors > 256))
- (void) SetImageType(image,PaletteType);
+ (void) SetImageType(image,PaletteType,exception);
}
else
{
Identify transparent colormap index.
*/
if ((image->storage_class == DirectClass) || (image->colors > 256))
- (void) SetImageType(image,PaletteBilevelMatteType);
+ (void) SetImageType(image,PaletteBilevelMatteType,exception);
for (i=0; i < (ssize_t) image->colors; i++)
if (image->colormap[i].alpha != OpaqueAlpha)
{
}
if (opacity == -1)
{
- (void) SetImageType(image,PaletteBilevelMatteType);
+ (void) SetImageType(image,PaletteBilevelMatteType,exception);
for (i=0; i < (ssize_t) image->colors; i++)
if (image->colormap[i].alpha != OpaqueAlpha)
{
/*
Convert X image to PseudoClass packets.
*/
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (i=0; i < (ssize_t) image->colors; i++)
{
image_info->depth=reference_types[j].depth;
(void) FormatLocaleString(reference_image->filename,MaxTextExtent,"%s:%s",
reference_formats[i].magick,output_filename);
- status=SetImageType(reference_image,reference_types[j].type);
+ status=SetImageType(reference_image,reference_types[j].type,exception);
InheritException(exception,&reference_image->exception);
if (status == MagickFalse)
{
image_info->depth=reference_types[j].depth;
(void) FormatLocaleString(reference_image->filename,MaxTextExtent,"%s:%s",
reference_formats[i].magick,output_filename);
- status=SetImageType(reference_image,reference_types[j].type);
+ status=SetImageType(reference_image,reference_types[j].type,exception);
InheritException(exception,&reference_image->exception);
if (status == MagickFalse)
{
(void) SetImageBackgroundColor(reference_image);
status=ImportImagePixels(reference_image,0,0,reference_image->columns,
reference_image->rows,reference_map[i],reference_storage[j].type,
- pixels);
- InheritException(exception,&reference_image->exception);
+ pixels,exception);
if (status == MagickFalse)
{
(void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
(void) SetImageBackgroundColor(reconstruct_image);
status=ImportImagePixels(reconstruct_image,0,0,reconstruct_image->columns,
reconstruct_image->rows,reference_map[i],reference_storage[j].type,
- pixels);
+ pixels,exception);
InheritException(exception,&reconstruct_image->exception);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
if (status == MagickFalse)
projects / imagemagick / commitdiff