diff --git a/.gitignore b/.gitignore
index 8c6b1cc..f4510f8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,3 +26,7 @@
 /netpbm-11.00.00.tar.xz
 /netpbm-11.01.00.tar.xz
 /netpbm-11.02.00.tar.xz
+/netpbm-11.09.00.tar.xz
+/netpbm-11.10.00.tar.xz
+/netpbm-11.12.00.tar.xz
+/netpbm-11.13.00.tar.xz
diff --git a/fix.patch b/fix.patch
new file mode 100644
index 0000000..b3c3cb9
--- /dev/null
+++ b/fix.patch
@@ -0,0 +1,1336 @@
+diff --git a/analyzer/pgmtexture.c b/analyzer/pgmtexture.c
+index c69643e..2e09dde 100644
+--- a/analyzer/pgmtexture.c
++++ b/analyzer/pgmtexture.c
+@@ -54,6 +54,7 @@ vector(unsigned int const nl,
+ 
+     assert(nh >= nl);
+ 
++    overflow_add(nh - nl, 1);
+     MALLOCARRAY(v, (unsigned) (nh - nl + 1));
+ 
+     if (v == NULL)
+@@ -85,6 +86,7 @@ matrix (unsigned int const nrl,
+     assert(nrh >= nrl);
+ 
+     /* allocate pointers to rows */
++    overflow_add(nrh - nrl, 1);
+     MALLOCARRAY(m, (unsigned) (nrh - nrl + 1));
+     if (m == NULL)
+         pm_error("Unable to allocate memory for a matrix.");
+@@ -93,6 +95,7 @@ matrix (unsigned int const nrl,
+ 
+     assert (nch >= ncl);
+ 
++    overflow_add(nch - ncl, 1);
+     /* allocate rows and set pointers to them */
+     for (i = nrl; i <= nrh; ++i) {
+         MALLOCARRAY(m[i], (unsigned) (nch - ncl + 1));
+diff --git a/converter/other/gemtopnm.c b/converter/other/gemtopnm.c
+index 6bbfcc0..24199cb 100644
+--- a/converter/other/gemtopnm.c
++++ b/converter/other/gemtopnm.c
+@@ -106,6 +106,7 @@ main(argc, argv)
+ 
+     pnm_writepnminit( stdout, cols, rows, MAXVAL, type, 0 );
+ 
++    overflow_add(cols, padright);
+     {
+         /* allocate input row data structure */
+         int plane;
+diff --git a/converter/other/jpegtopnm.c b/converter/other/jpegtopnm.c
+index 98552c0..311298c 100644
+--- a/converter/other/jpegtopnm.c
++++ b/converter/other/jpegtopnm.c
+@@ -862,6 +862,8 @@ convertImage(FILE *                          const ofP,
+     /* Calculate output image dimensions so we can allocate space */
+     jpeg_calc_output_dimensions(cinfoP);
+ 
++    overflow2(cinfoP->output_width, cinfoP->output_components);
++
+     /* Start decompressor */
+     jpeg_start_decompress(cinfoP);
+ 
+diff --git a/converter/other/pbmtopgm.c b/converter/other/pbmtopgm.c
+index 817fb5b..8baaa57 100644
+--- a/converter/other/pbmtopgm.c
++++ b/converter/other/pbmtopgm.c
+@@ -60,6 +60,7 @@ main(int argc, char *argv[]) {
+ 
+ 
+     outrow = pgm_allocrow(cols) ;
++    overflow2(width, height);
+     maxval = MIN(PGM_OVERALLMAXVAL, width*height);
+     pgm_writepgminit(stdout, cols, rows, maxval, 0) ;
+ 
+diff --git a/converter/other/pnmtoddif.c b/converter/other/pnmtoddif.c
+index b7b942b..52be0e4 100644
+--- a/converter/other/pnmtoddif.c
++++ b/converter/other/pnmtoddif.c
+@@ -629,6 +629,7 @@ main(int argc, char *argv[]) {
+     switch (PNM_FORMAT_TYPE(format)) {
+     case PBM_TYPE:
+         ip.bits_per_pixel = 1;
++        overflow_add(cols, 7);
+         ip.bytes_per_line = (cols + 7) / 8;
+         ip.spectral = 2;
+         ip.components = 1;
+@@ -644,6 +645,7 @@ main(int argc, char *argv[]) {
+         ip.polarity = 2;
+         break;
+     case PPM_TYPE:
++        overflow2(cols, 3);
+         ip.bytes_per_line = 3 * cols;
+         ip.bits_per_pixel = 24;
+         ip.spectral = 5;
+diff --git a/converter/other/pnmtojpeg.c b/converter/other/pnmtojpeg.c
+index e345831..39038f8 100644
+--- a/converter/other/pnmtojpeg.c
++++ b/converter/other/pnmtojpeg.c
+@@ -605,8 +605,10 @@ read_scan_script(j_compress_ptr const cinfo,
+            data, but if you want to compress multiple images you'd
+            want JPOOL_PERMANENT.
+         */
++        overflow2(nscans, sizeof(jpeg_scan_info));
+         const unsigned int scan_info_size = nscans * sizeof(jpeg_scan_info);
+-        jpeg_scan_info * const scan_info =
++        const jpeg_scan_info * scan_info;
++        scan_info =
+             (jpeg_scan_info *)
+             (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                         scan_info_size);
+@@ -938,6 +940,8 @@ compute_rescaling_array(JSAMPLE ** const rescale_p, const pixval maxval,
+   const long half_maxval = maxval / 2;
+   long val;
+ 
++  overflow_add(maxval, 1);
++  overflow2(maxval+1, sizeof(JSAMPLE));
+   *rescale_p = (JSAMPLE *)
+     (cinfo.mem->alloc_small) ((j_common_ptr) &cinfo, JPOOL_IMAGE,
+                               (size_t) (((long) maxval + 1L) *
+@@ -1016,6 +1020,7 @@ convert_scanlines(struct jpeg_compress_struct * const cinfo_p,
+     */
+ 
+   /* Allocate the libpnm output and compressor input buffers */
++  overflow2(cinfo_p->image_width, cinfo_p->input_components);
+   buffer = (*cinfo_p->mem->alloc_sarray)
+     ((j_common_ptr) cinfo_p, JPOOL_IMAGE,
+      (unsigned int) cinfo_p->image_width * cinfo_p->input_components,
+diff --git a/converter/other/pnmtops.c b/converter/other/pnmtops.c
+index 45d856d..5b04eeb 100644
+--- a/converter/other/pnmtops.c
++++ b/converter/other/pnmtops.c
+@@ -294,17 +294,21 @@ parseCommandLine(int argc, const char ** argv,
+     validateCompDimension(width, 72, "-width value");
+     validateCompDimension(height, 72, "-height value");
+ 
++    overflow2(width, 72);
+     cmdlineP->width  = width * 72;
++    overflow2(height, 72);
+     cmdlineP->height = height * 72;
+ 
+     if (imagewidthSpec) {
+         validateCompDimension(imagewidth, 72, "-imagewidth value");
++        overflow2(imagewidth, 72);
+         cmdlineP->imagewidth = imagewidth * 72;
+     }
+     else
+         cmdlineP->imagewidth = 0;
+     if (imageheightSpec) {
+-        validateCompDimension(imagewidth, 72, "-imageheight value");
++        validateCompDimension(imageheight, 72, "-imageheight value");
++        overflow2(imageheight, 72);
+         cmdlineP->imageheight = imageheight * 72;
+     }
+     else
+diff --git a/converter/other/rletopnm.c b/converter/other/rletopnm.c
+index 97f271d..72b63d3 100644
+--- a/converter/other/rletopnm.c
++++ b/converter/other/rletopnm.c
+@@ -19,6 +19,8 @@
+  * If you modify this software, you should include a notice giving the
+  * name of the person performing the modification, the date of modification,
+  * and the reason for such modification.
++ *
++ *  2002-12-19: Fix maths wrapping bugs. Alan Cox <alan@redhat.com>
+  */
+ /*
+  * rletopnm - A conversion program to convert from Utah's "rle" image format
+diff --git a/converter/other/sirtopnm.c b/converter/other/sirtopnm.c
+index fafcc91..9fe49d0 100644
+--- a/converter/other/sirtopnm.c
++++ b/converter/other/sirtopnm.c
+@@ -69,6 +69,7 @@ char* argv[];
+ 	    }
+ 	    break;
+ 	case PPM_TYPE:
++	    overflow3(cols, rows, 3);
+ 	    picsize = cols * rows * 3;
+ 	    planesize = cols * rows;
+             if ( !( sirarray = (unsigned char*) malloc( picsize ) ) ) 
+diff --git a/converter/other/tifftopnm.c b/converter/other/tifftopnm.c
+index 05493e7..7ea59fd 100644
+--- a/converter/other/tifftopnm.c
++++ b/converter/other/tifftopnm.c
+@@ -1372,6 +1372,7 @@ convertRasterByRows(pnmOut *       const pnmOutP,
+     if (scanbuf == NULL)
+         pm_error("can't allocate memory for scanline buffer");
+ 
++    overflow2(cols,spp);
+     MALLOCARRAY(samplebuf, cols * spp);
+     if (samplebuf == NULL)
+         pm_error("can't allocate memory for row buffer");
+diff --git a/converter/other/xwdtopnm.c b/converter/other/xwdtopnm.c
+index a74da34..4d26a31 100644
+--- a/converter/other/xwdtopnm.c
++++ b/converter/other/xwdtopnm.c
+@@ -210,6 +210,10 @@ processX10Header(X10WDFileHeader *  const h10P,
+         *colorsP = pnm_allocrow(2);
+         PNM_ASSIGN1((*colorsP)[0], 0);
+         PNM_ASSIGN1((*colorsP)[1], *maxvalP);
++        overflow_add(h10P->pixmap_width, 15);
++        if(h10P->pixmap_width < 0)
++            pm_error("assert: negative width");
++        overflow2((((h10P->pixmap_width + 15) / 16) * 16 - h10P->pixmap_width), 8);
+         *padrightP =
+             (((h10P->pixmap_width + 15) / 16) * 16 - h10P->pixmap_width) * 8;
+         *bits_per_itemP = 16;
+@@ -635,6 +639,7 @@ processX11Header(X11WDFileHeader *  const h11P,
+ 
+     *colsP = h11FixedP->pixmap_width;
+     *rowsP = h11FixedP->pixmap_height;
++    overflow2(h11FixedP->bytes_per_line, 8);
+     *padrightP =
+         h11FixedP->bytes_per_line * 8 -
+         h11FixedP->pixmap_width * h11FixedP->bits_per_pixel;
+diff --git a/converter/pbm/mdatopbm.c b/converter/pbm/mdatopbm.c
+index 461b3f8..c8bab6c 100644
+--- a/converter/pbm/mdatopbm.c
++++ b/converter/pbm/mdatopbm.c
+@@ -245,10 +245,13 @@ main(int argc, char **argv) {
+         pm_readlittleshort(infile, &yy); nInCols = yy;
+     }
+     
++    overflow2(nOutCols, 8);
+     nOutCols = 8 * nInCols;
+     nOutRows = nInRows;
+-    if (bScale) 
++    if (bScale) {
++        overflow2(nOutRows, 2);
+         nOutRows *= 2;
++    }
+ 
+     data = pbm_allocarray(nOutCols, nOutRows);
+     
+diff --git a/converter/pbm/mgrtopbm.c b/converter/pbm/mgrtopbm.c
+index 9f7004a..f2c1590 100644
+--- a/converter/pbm/mgrtopbm.c
++++ b/converter/pbm/mgrtopbm.c
+@@ -67,6 +67,7 @@ readMgrHeader(FILE *          const ifP,
+     
+     *colsP = (((int)head.h_wide - ' ') << 6) + ((int)head.l_wide - ' ');
+     *rowsP = (((int)head.h_high - ' ') << 6) + ((int) head.l_high - ' ');
++    overflow_add(*colsP, pad);
+     *padrightP = ( ( *colsP + pad - 1 ) / pad ) * pad - *colsP;
+ }
+ 
+diff --git a/converter/pbm/pbmto4425.c b/converter/pbm/pbmto4425.c
+index 1d97ac6..c4c8cbb 100644
+--- a/converter/pbm/pbmto4425.c
++++ b/converter/pbm/pbmto4425.c
+@@ -2,6 +2,7 @@
+ 
+ #include "nstring.h"
+ #include "pbm.h"
++#include <string.h>
+ 
+ static char bit_table[2][3] = {
+ {1, 4, 0x10},
+@@ -160,7 +161,7 @@ main(int argc, char * argv[]) {
+     xres = vmap_width * 2;
+     yres = vmap_height * 3;
+ 
+-    vmap = malloc(vmap_width * vmap_height * sizeof(char));
++    vmap = malloc3(vmap_width, vmap_height, sizeof(char));
+     if(vmap == NULL)
+ 	{
+         pm_error( "Cannot allocate memory" );
+diff --git a/converter/pbm/pbmtogem.c b/converter/pbm/pbmtogem.c
+index 4fd30e9..c82757d 100644
+--- a/converter/pbm/pbmtogem.c
++++ b/converter/pbm/pbmtogem.c
+@@ -79,6 +79,7 @@ putinit (int const rows, int const cols)
+   bitsperitem = 0;
+   bitshift = 7;
+   outcol = 0;
++  overflow_add(cols, 7);
+   outmax = (cols + 7) / 8;
+   outrow = (unsigned char *) pm_allocrow (outmax, sizeof (unsigned char));
+   lastrow = (unsigned char *) pm_allocrow (outmax, sizeof (unsigned char));
+diff --git a/converter/pbm/pbmtogo.c b/converter/pbm/pbmtogo.c
+index 4f84f39..943dc84 100644
+--- a/converter/pbm/pbmtogo.c
++++ b/converter/pbm/pbmtogo.c
+@@ -158,6 +158,7 @@ main(int           argc,
+     bitrow = pbm_allocrow(cols);
+ 
+     /* Round cols up to the nearest multiple of 8. */
++    overflow_add(cols, 7);
+     rucols = ( cols + 7 ) / 8;
+     bytesperrow = rucols;       /* GraphOn uses bytes */
+     rucols = rucols * 8;
+diff --git a/converter/pbm/pbmtolj.c b/converter/pbm/pbmtolj.c
+index 3cd7670..0b51932 100644
+--- a/converter/pbm/pbmtolj.c
++++ b/converter/pbm/pbmtolj.c
+@@ -120,7 +120,11 @@ parseCommandLine(int argc, char ** argv,
+ static void
+ allocateBuffers(unsigned int const cols) {
+ 
++    overflow_add(cols, 8);
+     rowBufferSize = (cols + 7) / 8;
++    overflow_add(rowBufferSize, 128);
++    overflow_add(rowBufferSize, rowBufferSize+128);
++    overflow_add(rowBufferSize+10, rowBufferSize/8);
+     packBufferSize = rowBufferSize + (rowBufferSize + 127) / 128 + 1;
+     deltaBufferSize = rowBufferSize + rowBufferSize / 8 + 10;
+ 
+diff --git a/converter/pbm/pbmtomda.c b/converter/pbm/pbmtomda.c
+index 3ad5149..9efe5cf 100644
+--- a/converter/pbm/pbmtomda.c
++++ b/converter/pbm/pbmtomda.c
+@@ -179,6 +179,7 @@ int main(int argc, char **argv)
+     
+     nOutRowsUnrounded = bScale ? nInRows/2 : nInRows;
+ 
++    overflow_add(nOutRowsUnrounded, 3);
+     nOutRows = ((nOutRowsUnrounded + 3) / 4) * 4;
+         /* MDA wants rows a multiple of 4 */   
+     nOutCols = nInCols / 8;
+diff --git a/converter/pbm/pbmtoppa/pbm.c b/converter/pbm/pbmtoppa/pbm.c
+index ae36e0d..b8c89c9 100644
+--- a/converter/pbm/pbmtoppa/pbm.c
++++ b/converter/pbm/pbmtoppa/pbm.c
+@@ -154,6 +154,7 @@ pbm_readline(pbm_stat *      const pbmStatP,
+                 break;
+             case P4: {
+                 int tmp, tmp2;
++                overflow_add(pbmStatP->width, 7);
+                 tmp = (pbmStatP->width+7)/8;
+                 tmp2 = fread(data,1,tmp,pbmStatP->fptr);
+                 if (tmp2 == tmp) {
+@@ -186,6 +187,7 @@ pbm_unreadline(pbm_stat * const pbmStatP,
+ 
+     if (!pbmStatP->unread) {
+         pbmStatP->unread = 1;
++        overflow_add(pbmStatP->width, 7);
+         pbmStatP->revdata = malloc ((pbmStatP->width+7)/8);
+         memcpy(pbmStatP->revdata, data, (pbmStatP->width+7)/8);
+         --pbmStatP->current_line;
+diff --git a/converter/pbm/pbmtoppa/pbmtoppa.c b/converter/pbm/pbmtoppa/pbmtoppa.c
+index ff4a599..aa510ec 100644
+--- a/converter/pbm/pbmtoppa/pbmtoppa.c
++++ b/converter/pbm/pbmtoppa/pbmtoppa.c
+@@ -453,6 +453,7 @@ main(int argc, char *argv[]) {
+             pm_error("main(): unrecognized parameter '%s'", argv[argn]);
+     }
+ 
++    overflow_add(Width, 7);
+     Pwidth=(Width+7)/8;
+     printer.fptr=out;
+ 
+diff --git a/converter/pbm/pbmtoxbm.c b/converter/pbm/pbmtoxbm.c
+index ecb72b3..600461f 100644
+--- a/converter/pbm/pbmtoxbm.c
++++ b/converter/pbm/pbmtoxbm.c
+@@ -352,6 +352,7 @@ convertRaster(FILE *          const ifP,
+ 
+     unsigned char * bitrow;
+     unsigned int row;
++    overflow_add(cols, padright);
+ 
+     putinit(xbmVersion);
+ 
+diff --git a/converter/pbm/pktopbm.c b/converter/pbm/pktopbm.c
+index 712f339..b6fcb02 100644
+--- a/converter/pbm/pktopbm.c
++++ b/converter/pbm/pktopbm.c
+@@ -280,6 +280,7 @@ main(int argc, char *argv[]) {
+         if (flagbyte == 7) {            /* long form preamble */
+             integer packetlength = get32() ;    /* character packet length */
+             car = get32() ;         /* character number */
++            overflow_add(packetlength, pktopbm_pkloc);
+             endofpacket = packetlength + pktopbm_pkloc;
+                 /* calculate end of packet */
+             if ((car >= MAXPKCHAR) || !filename[car]) {
+diff --git a/converter/pbm/thinkjettopbm.l b/converter/pbm/thinkjettopbm.l
+index 5de4f2b..cc1810c 100644
+--- a/converter/pbm/thinkjettopbm.l
++++ b/converter/pbm/thinkjettopbm.l
+@@ -114,7 +114,9 @@ DIG             [0-9]
+ <RASTERMODE>\033\*b{DIG}+W  {
+                             int l;
+                             if (rowCount >= rowCapacity) {
++                                overflow_add(rowCapacity, 100);
+                                 rowCapacity += 100;
++                                overflow2(rowCapacity, sizeof *rows);
+                                 rows = realloc (rows, rowCapacity * sizeof *rows);
+                                 if (rows == NULL)
+                                     pm_error ("Out of memory.");
+@@ -226,6 +228,7 @@ yywrap (void)
+     /*
+      * Quite simple since ThinkJet bit arrangement matches PBM
+      */
++    overflow2(maxRowLength, 8);
+     pbm_writepbminit(stdout, maxRowLength*8, rowCount, 0);
+ 
+     packed_bitrow = malloc(maxRowLength);
+diff --git a/converter/pbm/ybmtopbm.c b/converter/pbm/ybmtopbm.c
+index 2a42908..cf1ff03 100644
+--- a/converter/pbm/ybmtopbm.c
++++ b/converter/pbm/ybmtopbm.c
+@@ -43,6 +43,7 @@ getinit(FILE *  const ifP,
+         pm_error("EOF / read error");
+ 
+     *depthP = 1;
++    overflow_add(*colsP, 15);
+ }
+ 
+ 
+diff --git a/converter/pgm/lispmtopgm.c b/converter/pgm/lispmtopgm.c
+index 40dd3fb..8dd9cae 100644
+--- a/converter/pgm/lispmtopgm.c
++++ b/converter/pgm/lispmtopgm.c
+@@ -58,6 +58,7 @@ main( argc, argv )
+         pm_error( "depth (%d bits) is too large", depth);
+ 
+     pgm_writepgminit( stdout, cols, rows, (gray) maxval, 0 );
++    overflow_add(cols, 7);
+     grayrow = pgm_allocrow( ( cols + 7 ) / 8 * 8 );
+ 
+     for ( row = 0; row < rows; ++row )
+@@ -103,6 +104,7 @@ getinit( file, colsP, rowsP, depthP, padrightP )
+     if ( *depthP == 0 )
+ 	*depthP = 1;	/* very old file */
+     
++    overflow_add((int)colsP, 31);
+     *padrightP = ( ( *colsP + 31 ) / 32 ) * 32 - *colsP;
+     
+     if ( *colsP != (cols_32 - *padrightP) ) {
+diff --git a/converter/pgm/psidtopgm.c b/converter/pgm/psidtopgm.c
+index 07417d1..25bb311 100644
+--- a/converter/pgm/psidtopgm.c
++++ b/converter/pgm/psidtopgm.c
+@@ -78,6 +78,7 @@ main(int     argc,
+         pm_error("bits/sample (%d) is too large.", bitspersample);
+ 
+     pgm_writepgminit(stdout, cols, rows, maxval, 0);
++    overflow_add(cols, 7);
+     grayrow = pgm_allocrow((cols + 7) / 8 * 8);
+     for (row = 0; row < rows; ++row) {
+         unsigned int col;
+diff --git a/converter/ppm/Makefile b/converter/ppm/Makefile
+index 003ef8d..b97349d 100644
+--- a/converter/ppm/Makefile
++++ b/converter/ppm/Makefile
+@@ -11,7 +11,7 @@ SUBDIRS = hpcdtoppm ppmtompeg
+ 
+ PORTBINARIES =	411toppm eyuvtoppm gouldtoppm ilbmtoppm imgtoppm \
+ 		leaftoppm mtvtoppm neotoppm \
+-		pcxtoppm pc1toppm pi1toppm picttoppm pjtoppm \
++		pcxtoppm pc1toppm pi1toppm pjtoppm \
+ 		ppmtoacad ppmtoapplevol ppmtoarbtxt ppmtoascii \
+ 		ppmtobmp ppmtoeyuv ppmtogif ppmtoicr ppmtoilbm \
+ 		ppmtoleaf ppmtolj ppmtomitsu ppmtoneo \
+diff --git a/converter/ppm/ilbmtoppm.c b/converter/ppm/ilbmtoppm.c
+index b9b8986..f4fe331 100644
+--- a/converter/ppm/ilbmtoppm.c
++++ b/converter/ppm/ilbmtoppm.c
+@@ -608,6 +608,7 @@ decode_row(FILE *          const ifP,
+     rawtype *chp;
+ 
+     cols = bmhdP->w;
++    overflow_add(cols, 15);
+     bytes = RowBytes(cols);
+     for( plane = 0; plane < nPlanes; plane++ ) {
+         int mask;
+@@ -695,6 +696,23 @@ decode_mask(FILE *          const ifP,
+  Multipalette handling
+  ****************************************************************************/
+ 
++static void *
++xmalloc2(x, y)
++    int x;
++    int y;
++{
++    void *mem;
++
++    overflow2(x,y);
++    if( x * y == 0 )
++        return NULL;
++
++    mem = malloc2(x,y);
++    if( mem == NULL )
++        pm_error("out of memory allocating %d bytes", x * y);
++    return mem;
++}
++
+ 
+ static void
+ multi_adjust(ColorMap *            const cmapP,
+@@ -1363,6 +1381,9 @@ dcol_to_ppm(FILE *         const ifP,
+     if( redmaxval != maxval || greenmaxval != maxval || bluemaxval != maxval )
+         pm_message("scaling colors to %d bits", pm_maxvaltobits(maxval));
+ 
++    overflow_add(redmaxval, 1);
++    overflow_add(greenmaxval, 1);
++    overflow_add(bluemaxval, 1);
+     MALLOCARRAY_NOFAIL(redtable,   redmaxval   +1);
+     MALLOCARRAY_NOFAIL(greentable, greenmaxval +1);
+     MALLOCARRAY_NOFAIL(bluetable,  bluemaxval  +1);
+@@ -1802,7 +1823,9 @@ PCHG_ConvertSmall(PCHGHeader *    const pchgP,
+             ChangeCount32 = *data++;
+             remDataSize -= 2;
+ 
++            overflow_add(ChangeCount16, ChangeCount32);
+             changes = ChangeCount16 + ChangeCount32;
++            overflow_add(changes, 1);
+             for (i = 0; i < changes; ++i) {
+                 if (totalchanges >= pchgP->TotalChanges) goto fail;
+                 if (remDataSize < 2) goto fail;
+@@ -2067,6 +2090,9 @@ read_pchg(FILE *     const ifP,
+             cmap->mp_change[i] = NULL;
+         if( PCHG.StartLine < 0 ) {
+             int nch;
++            if(PCHG.MaxReg < PCHG.MinReg)
++                pm_error("assert: MinReg > MaxReg");
++            overflow_add(PCHG.MaxReg-PCHG.MinReg, 2);
+             nch = PCHG.MaxReg - PCHG.MinReg +1;
+             MALLOCARRAY_NOFAIL(cmap->mp_init, nch + 1);
+             for( i = 0; i < nch; i++ )
+@@ -2143,6 +2169,7 @@ process_body( FILE *          const ifP,
+     if (typeid == ID_ILBM) {
+         int isdeep;
+ 
++        overflow_add(bmhdP->w, 15);
+         MALLOCARRAY_NOFAIL(ilbmrow, RowBytes(bmhdP->w));
+         *viewportmodesP |= fakeviewport;      /* -isham/-isehb */
+ 
+diff --git a/converter/ppm/imgtoppm.c b/converter/ppm/imgtoppm.c
+index 7078b88..eb8509e 100644
+--- a/converter/ppm/imgtoppm.c
++++ b/converter/ppm/imgtoppm.c
+@@ -84,6 +84,7 @@ main(int argc, char ** argv) {
+             len = atoi((char*) buf );
+             if ( fread( buf, len, 1, ifp ) != 1 )
+                 pm_error( "bad colormap buf" );
++            overflow2(cmaplen, 3);
+             if ( cmaplen * 3 != len )
+             {
+                 pm_message(
+@@ -105,6 +106,7 @@ main(int argc, char ** argv) {
+                 pm_error( "bad pixel data header" );
+             buf[8] = '\0';
+             len = atoi((char*) buf );
++            overflow2(cols, rows);
+             if ( len != cols * rows )
+                 pm_message(
+                     "pixel data length (%d) does not match image size (%d)",
+diff --git a/converter/ppm/pcxtoppm.c b/converter/ppm/pcxtoppm.c
+index e252ba2..270ae3b 100644
+--- a/converter/ppm/pcxtoppm.c
++++ b/converter/ppm/pcxtoppm.c
+@@ -409,6 +409,7 @@ pcx_planes_to_pixels(pixels, bitplanes, bytesperline, planes, bitsperpixel)
+     /*
+      * clear the pixel buffer
+      */
++    overflow2(bytesperline, 8);
+     npixels = (bytesperline * 8) / bitsperpixel;
+     p    = pixels;
+     while (--npixels >= 0)
+@@ -470,6 +471,7 @@ pcx_16col_to_ppm(FILE *       const ifP,
+     }
+ 
+     /*  BytesPerLine should be >= BitsPerPixel * cols / 8  */
++    overflow2(BytesPerLine, 8);
+     rawcols = BytesPerLine * 8 / BitsPerPixel;
+     if (headerCols > rawcols) {
+         pm_message("warning - BytesPerLine = %d, "
+diff --git a/converter/ppm/picttoppm.c b/converter/ppm/picttoppm.c
+index 9cf570e..6020f67 100644
+--- a/converter/ppm/picttoppm.c
++++ b/converter/ppm/picttoppm.c
+@@ -1,3 +1,4 @@
++#error "Unfixable. Don't ship me"
+ /*
+  * picttoppm.c -- convert a MacIntosh PICT file to PPM format.
+  *
+diff --git a/converter/ppm/pjtoppm.c b/converter/ppm/pjtoppm.c
+index ffb01d0..eb11e8d 100644
+--- a/converter/ppm/pjtoppm.c
++++ b/converter/ppm/pjtoppm.c
+@@ -149,12 +149,17 @@ main(int argc, const char ** argv) {
+                 case 'V':   /* send plane */
+                 case 'W':   /* send last plane */
+                     if (rows == -1 || row >= rows || image == NULL) {
+-                        if (rows == -1 || row >= rows)
++                        if (rows == -1 || row >= rows) {
++                            overflow_add(rows, 100);
+                             rows += 100;
++                        }
++
+                         if (image == NULL) {
++                            overflow2(rows,planes);
+                             MALLOCARRAY(image, uintProduct(rows, planes));
+                             MALLOCARRAY(imlen, uintProduct(rows, planes));
+                         } else {
++                            overflow2(rows,planes);
+                             REALLOCARRAY(image, uintProduct(rows, planes));
+                             REALLOCARRAY(imlen, uintProduct(rows, planes));
+                         }
+@@ -235,8 +240,10 @@ main(int argc, const char ** argv) {
+                      col += 2)
+                     for (cmd = image[plane + row * planes][col],
+                              val = image[plane + row * planes][col+1];
+-                         cmd >= 0 && i < newcols; cmd--, i++)
++                         cmd >= 0 && i < newcols; cmd--, i++) {
+                         buf[i] = val;
++                        overflow_add(i, 1);
++                    }
+                 cols = MAX(cols, i);
+                 free(image[plane + row * planes]);
+                 /*
+@@ -247,6 +254,7 @@ main(int argc, const char ** argv) {
+                 image[plane + row * planes] = realloc(buf, i);
+             }
+         }
++        overflow2(cols, 8);
+         cols *= 8;
+     }
+ 
+diff --git a/converter/ppm/ppmtoeyuv.c b/converter/ppm/ppmtoeyuv.c
+index f5ce115..6f072be 100644
+--- a/converter/ppm/ppmtoeyuv.c
++++ b/converter/ppm/ppmtoeyuv.c
+@@ -114,6 +114,7 @@ create_multiplication_tables(const pixval maxval) {
+ 
+     int index;
+ 
++    overflow_add(maxval, 1);
+     MALLOCARRAY_NOFAIL(mult299   , maxval+1);
+     MALLOCARRAY_NOFAIL(mult587   , maxval+1);
+     MALLOCARRAY_NOFAIL(mult114   , maxval+1);
+diff --git a/converter/ppm/ppmtolj.c b/converter/ppm/ppmtolj.c
+index 7ed814e..b4e7db1 100644
+--- a/converter/ppm/ppmtolj.c
++++ b/converter/ppm/ppmtolj.c
+@@ -182,6 +182,7 @@ int main(int argc, char *argv[]) {
+     ppm_readppminit( ifp, &cols, &rows, &maxval, &format );
+     pixelrow = ppm_allocrow( cols );
+ 
++    overflow2(cols, 6);
+     obuf = (unsigned char *) pm_allocrow(cols * 3, sizeof(unsigned char));
+     cbuf = (unsigned char *) pm_allocrow(cols * 6, sizeof(unsigned char));
+     if (mode == C_TRANS_MODE_DELTA)
+diff --git a/converter/ppm/ppmtomitsu.c b/converter/ppm/ppmtomitsu.c
+index 50b790d..63d3182 100644
+--- a/converter/ppm/ppmtomitsu.c
++++ b/converter/ppm/ppmtomitsu.c
+@@ -685,6 +685,8 @@ main(int argc, char * argv[]) {
+         medias = MSize_User;
+ 
+     if (dpi300) {
++        overflow2(medias.maxcols, 2);
++        overflow2(medias.maxrows, 2);
+         medias.maxcols *= 2;
+         medias.maxrows *= 2;
+     }
+diff --git a/converter/ppm/ppmtopcx.c b/converter/ppm/ppmtopcx.c
+index 76f0629..e7b06ff 100644
+--- a/converter/ppm/ppmtopcx.c
++++ b/converter/ppm/ppmtopcx.c
+@@ -422,6 +422,8 @@ ppmTo16ColorPcx(pixel **            const pixels,
+             else                   Planes = 1;
+         }
+     }
++    overflow2(BitsPerPixel, cols);
++    overflow_add(BitsPerPixel * cols, 7);
+     BytesPerLine = ((cols * BitsPerPixel) + 7) / 8;
+     MALLOCARRAY_NOFAIL(indexRow, cols);
+     MALLOCARRAY_NOFAIL(planesrow, BytesPerLine);
+diff --git a/converter/ppm/ppmtopict.c b/converter/ppm/ppmtopict.c
+index 36464b6..c91ccf2 100644
+--- a/converter/ppm/ppmtopict.c
++++ b/converter/ppm/ppmtopict.c
+@@ -450,6 +450,8 @@ main(int argc, const char ** argv) {
+     putShort(stdout, 0);            /* mode */
+ 
+     /* Finally, write out the data. */
++    overflow_add(cols/MAX_COUNT, 1);
++    overflow_add(cols, cols/MAX_COUNT+1);
+     outBuf = malloc((unsigned)(cols+cols/MAX_COUNT+1));
+     for (row = 0, oc = 0; row < rows; ++row) {
+         unsigned int rowSize;
+diff --git a/converter/ppm/ppmtopj.c b/converter/ppm/ppmtopj.c
+index d116773..49d08fc 100644
+--- a/converter/ppm/ppmtopj.c
++++ b/converter/ppm/ppmtopj.c
+@@ -179,6 +179,7 @@ char *argv[];
+ 	pixels = ppm_readppm( ifp, &cols, &rows, &maxval );
+ 
+ 	pm_close( ifp );
++	overflow2(cols,2);
+ 	obuf = (unsigned char *) pm_allocrow(cols, sizeof(unsigned char));
+ 	cbuf = (unsigned char *) pm_allocrow(cols * 2, sizeof(unsigned char));
+ 
+diff --git a/converter/ppm/ppmtopjxl.c b/converter/ppm/ppmtopjxl.c
+index 90bcef0..72d0027 100644
+--- a/converter/ppm/ppmtopjxl.c
++++ b/converter/ppm/ppmtopjxl.c
+@@ -267,6 +267,9 @@ main(int argc, const char * argv[]) {
+     if (maxval > PCL_MAXVAL)
+         pm_error("color range too large; reduce with ppmcscale");
+ 
++    if (cols < 0 || rows < 0)
++        pm_error("negative size is not possible");
++
+     /* Figure out the colormap. */
+     pm_message("Computing colormap...");
+     chv = ppm_computecolorhist(pixels, cols, rows, MAXCOLORS, &colors);
+@@ -286,6 +289,8 @@ main(int argc, const char * argv[]) {
+         case 0: /* direct mode (no palette) */
+             bpp = bitsperpixel(maxval); /* bits per pixel */
+             bpg = bpp; bpb = bpp;
++            overflow2(bpp, 3);
++            overflow_add(bpp*3, 7);
+             bpp = (bpp*3+7)>>3;     /* bytes per pixel now */
+             bpr = (bpp<<3)-bpg-bpb; 
+             bpp *= cols;            /* bytes per row now */
+@@ -295,9 +300,13 @@ main(int argc, const char * argv[]) {
+         case 3: case 7: pclindex++;
+         default:
+             bpp = 8/pclindex;
++            overflow_add(cols, bpp);
++            if(bpp == 0)
++                pm_error("assert: no bpp");
+             bpp = (cols+bpp-1)/bpp;      /* bytes per row */
+         }
+     }
++    overflow2(bpp,2);
+     inrow = (char *)malloc((unsigned)bpp);
+     outrow = (char *)malloc((unsigned)bpp*2);
+     runcnt = (signed char *)malloc((unsigned)bpp);
+diff --git a/converter/ppm/ppmtowinicon.c b/converter/ppm/ppmtowinicon.c
+index c673798..f026c08 100644
+--- a/converter/ppm/ppmtowinicon.c
++++ b/converter/ppm/ppmtowinicon.c
+@@ -12,6 +12,7 @@
+ 
+ #include <math.h>
+ #include <string.h>
++#include <stdlib.h>
+ 
+ #include "pm_c_util.h"
+ #include "winico.h"
+@@ -214,6 +215,7 @@ createAndBitmap (gray ** const ba, int const cols, int const rows,
+    MALLOCARRAY_NOFAIL(rowData, rows);
+    icBitmap->xBytes = xBytes;
+    icBitmap->data   = rowData;
++   overflow2(xBytes, rows);
+    icBitmap->size   = xBytes * rows;
+    for (y=0;y<rows;y++) {
+       u1 * row;
+@@ -342,6 +344,7 @@ create4Bitmap (pixel ** const pa, int const cols, int const rows,
+    MALLOCARRAY_NOFAIL(rowData, rows);
+    icBitmap->xBytes = xBytes;
+    icBitmap->data   = rowData;
++   overflow2(xBytes, rows);
+    icBitmap->size   = xBytes * rows;
+ 
+    for (y=0;y<rows;y++) {
+@@ -402,6 +405,7 @@ create8Bitmap (pixel ** const pa, int const cols, int const rows,
+    MALLOCARRAY_NOFAIL(rowData, rows);
+    icBitmap->xBytes = xBytes;
+    icBitmap->data   = rowData;
++   overflow2(xBytes, rows);
+    icBitmap->size   = xBytes * rows;
+ 
+    for (y=0;y<rows;y++) {
+@@ -709,6 +713,10 @@ addEntryToIcon(MS_Ico       const MSIconData,
+     entry->bitcount      = bpp;
+     entry->ih            = createInfoHeader(entry, xorBitmap, andBitmap);
+     entry->colors        = palette->colors;
++    overflow2(4, entry->color_count);
++    overflow_add(xorBitmap->size, andBitmap->size);
++    overflow_add(xorBitmap->size + andBitmap->size, 40);
++    overflow_add(xorBitmap->size + andBitmap->size + 40, 4 * entry->color_count);
+     entry->size_in_bytes = 
+         xorBitmap->size + andBitmap->size + 40 + (4 * entry->color_count);
+     if (verbose) 
+diff --git a/converter/ppm/ppmtoxpm.c b/converter/ppm/ppmtoxpm.c
+index 0e31692..1b3923f 100644
+--- a/converter/ppm/ppmtoxpm.c
++++ b/converter/ppm/ppmtoxpm.c
+@@ -198,6 +198,7 @@ genNumstr(unsigned int const input, int const digits) {
+     unsigned int i;
+ 
+     /* Allocate memory for printed number.  Abort if error. */
++    overflow_add(digits, 1);
+     if (!(str = (char *) malloc(digits + 1)))
+         pm_error("out of memory");
+ 
+@@ -315,6 +316,7 @@ genCmap(colorhist_vector const chv,
+     unsigned int charsPerPixel;
+     unsigned int xpmMaxval;
+     
++    if (includeTransparent) overflow_add(ncolors, 1);
+     MALLOCARRAY(cmap, cmapSize);
+     if (cmapP == NULL)
+         pm_error("Out of memory allocating %u bytes for a color map.",
+diff --git a/converter/ppm/qrttoppm.c b/converter/ppm/qrttoppm.c
+index 935463e..653084c 100644
+--- a/converter/ppm/qrttoppm.c
++++ b/converter/ppm/qrttoppm.c
+@@ -46,7 +46,7 @@ main( argc, argv )
+ 
+     ppm_writeppminit( stdout, cols, rows, maxval, 0 );
+     pixelrow = ppm_allocrow( cols );
+-    buf = (unsigned char *) malloc( 3 * cols );
++    buf = (unsigned char *) malloc2( 3 , cols );
+     if ( buf == (unsigned char *) 0 )
+ 	pm_error( "out of memory" );
+ 
+diff --git a/converter/ppm/sldtoppm.c b/converter/ppm/sldtoppm.c
+index 2fef023..ce73025 100644
+--- a/converter/ppm/sldtoppm.c
++++ b/converter/ppm/sldtoppm.c
+@@ -506,6 +506,8 @@ slider(slvecfn   slvec,
+ 
+     /* Allocate image buffer and clear it to black. */
+ 
++    overflow_add(ixdots, 1);
++    overflow_add(iydots, 1);
+     pixels = ppm_allocarray(pixcols = ixdots + 1, pixrows = iydots + 1);
+     PPM_ASSIGN(rgbcolor, 0, 0, 0);
+     ppmd_filledrectangle(pixels, pixcols, pixrows, pixmaxval, 0, 0,
+diff --git a/converter/ppm/ximtoppm.c b/converter/ppm/ximtoppm.c
+index 9620942..e9083f3 100644
+--- a/converter/ppm/ximtoppm.c
++++ b/converter/ppm/ximtoppm.c
+@@ -118,6 +118,7 @@ ReadXimHeader(FILE *     const in_fp,
+     header->bits_channel = atoi(a_head.bits_per_channel);
+     header->alpha_flag = atoi(a_head.alpha_channel);
+     if (strlen(a_head.author)) {
++        overflow_add(strlen(a_head.author),1);
+         if (!(header->author = calloc((unsigned int)strlen(a_head.author)+1,
+                 1))) {
+             pm_message("ReadXimHeader: can't calloc author string" );
+@@ -127,6 +128,7 @@ ReadXimHeader(FILE *     const in_fp,
+         strncpy(header->author, a_head.author, strlen(a_head.author));
+     }
+     if (strlen(a_head.date)) {
++        overflow_add(strlen(a_head.date),1);
+         if (!(header->date =calloc((unsigned int)strlen(a_head.date)+1,1))){
+             pm_message("ReadXimHeader: can't calloc date string" );
+             return(0);
+@@ -135,6 +137,7 @@ ReadXimHeader(FILE *     const in_fp,
+         strncpy(header->date, a_head.date, strlen(a_head.date));
+     }
+     if (strlen(a_head.program)) {
++        overflow_add(strlen(a_head.program),1);
+         if (!(header->program = calloc(
+                     (unsigned int)strlen(a_head.program) + 1, 1))) {
+             pm_message("ReadXimHeader: can't calloc program string" );
+@@ -161,6 +164,7 @@ ReadXimHeader(FILE *     const in_fp,
+     if (header->nchannels == 3 && header->bits_channel == 8)
+         header->ncolors = 0;
+     else if (header->nchannels == 1 && header->bits_channel == 8) {
++        overflow2(header->ncolors, sizeof(Color));
+         header->colors = (Color *)calloc((unsigned int)header->ncolors,
+                 sizeof(Color));
+         if (header->colors == NULL) {
+diff --git a/editor/pamcut.c b/editor/pamcut.c
+index 1fc9d9b..ad0e030 100644
+--- a/editor/pamcut.c
++++ b/editor/pamcut.c
+@@ -799,6 +799,8 @@ cutOneImage(FILE *             const ifP,
+ 
+     outpam = inpam;    /* Initial value -- most fields should be same */
+     outpam.file   = ofP;
++    overflow_add(rightcol, 1);
++    overflow_add(bottomrow, 1);
+     outpam.width  = rightcol - leftcol + 1;
+     outpam.height = bottomrow - toprow + 1;
+ 
+diff --git a/editor/pnmgamma.c b/editor/pnmgamma.c
+index 1fdf20e..98b7e90 100644
+--- a/editor/pnmgamma.c
++++ b/editor/pnmgamma.c
+@@ -596,6 +596,7 @@ createGammaTables(enum transferFunction const transferFunction,
+                   xelval **             const btableP) {
+ 
+     /* Allocate space for the tables. */
++    overflow_add(maxval, 1);
+     MALLOCARRAY(*rtableP, maxval+1);
+     MALLOCARRAY(*gtableP, maxval+1);
+     MALLOCARRAY(*btableP, maxval+1);
+diff --git a/editor/pnmhisteq.c b/editor/pnmhisteq.c
+index a339f73..c2c85a3 100644
+--- a/editor/pnmhisteq.c
++++ b/editor/pnmhisteq.c
+@@ -107,6 +107,7 @@ computeLuminosityHistogram(xel * const *   const xels,
+     unsigned int pixelCount;
+     unsigned int * lumahist;
+ 
++    overflow_add(maxval, 1);
+     MALLOCARRAY(lumahist, maxval + 1);
+     if (lumahist == NULL)
+         pm_error("Out of storage allocating array for %u histogram elements",
+diff --git a/editor/pnmindex.csh b/editor/pnmindex.csh
+index c6f1e84..c513a84 100755
+--- a/editor/pnmindex.csh
++++ b/editor/pnmindex.csh
+@@ -1,5 +1,7 @@
+ #!/bin/csh -f
+ #
++echo "Unsafe code, needs debugging, do not ship"
++exit 1
+ # pnmindex - build a visual index of a bunch of anymaps
+ #
+ # Copyright (C) 1991 by Jef Poskanzer.
+diff --git a/editor/pnmpad.c b/editor/pnmpad.c
+index 55cdcd6..10da3af 100644
+--- a/editor/pnmpad.c
++++ b/editor/pnmpad.c
+@@ -654,6 +654,8 @@ main(int argc, const char ** argv) {
+ 
+     computePadSizes(cmdline, cols, rows, &lpad, &rpad, &tpad, &bpad);
+ 
++    overflow_add(cols, lpad);
++    overflow_add(cols + lpad, rpad);
+     newcols = cols + lpad + rpad;
+ 
+     if (cmdline.reportonly)
+diff --git a/editor/pnmremap.c b/editor/pnmremap.c
+index 0c0096b..8b86cb7 100644
+--- a/editor/pnmremap.c
++++ b/editor/pnmremap.c
+@@ -468,6 +468,7 @@ fserr_init(struct pam *   const pamP,
+ 
+     unsigned int const fserrSize = pamP->width + 2;
+ 
++    overflow_add(pamP->width, 2);
+     fserrP->width = pamP->width;
+ 
+     MALLOCARRAY(fserrP->thiserr, pamP->depth);
+@@ -506,6 +507,7 @@ floydInitRow(struct pam *   const pamP,
+ 
+     unsigned int col;
+ 
++    overflow_add(pamP->width, 2);
+     for (col = 0; col < pamP->width + 2; ++col) {
+         unsigned int plane;
+         for (plane = 0; plane < pamP->depth; ++plane)
+diff --git a/editor/pnmscalefixed.c b/editor/pnmscalefixed.c
+index 884ca31..f4d7086 100644
+--- a/editor/pnmscalefixed.c
++++ b/editor/pnmscalefixed.c
+@@ -214,6 +214,7 @@ compute_output_dimensions(const struct cmdline_info cmdline,
+                           const int rows, const int cols,
+                           int * newrowsP, int * newcolsP) {
+ 
++    overflow2(rows, cols);
+     if (cmdline.pixels) {
+         if (rows * cols <= cmdline.pixels) {
+             *newrowsP = rows;
+@@ -265,6 +266,7 @@ compute_output_dimensions(const struct cmdline_info cmdline,
+ 
+     if (*newcolsP < 1) *newcolsP = 1;
+     if (*newrowsP < 1) *newrowsP = 1;
++    overflow2(*newcolsP, *newrowsP);
+ }        
+ 
+ 
+@@ -446,6 +448,8 @@ main(int argc, char **argv ) {
+        unfilled.  We can address that by stretching, whereas the other
+        case would require throwing away some of the input.
+     */
++    overflow2(newcols, SCALE);
++    overflow2(newrows, SCALE);
+     sxscale = SCALE * newcols / cols;
+     syscale = SCALE * newrows / rows;
+ 
+diff --git a/editor/ppmdither.c b/editor/ppmdither.c
+index ec1b977..c46a974 100644
+--- a/editor/ppmdither.c
++++ b/editor/ppmdither.c
+@@ -352,6 +352,9 @@ dithMatrix(unsigned int const dithPower) {
+     assert(dithPower < sizeof(unsigned int) * 8);
+ 
+     {
++        overflow2(dithDim, sizeof(*dithMat));
++        overflow3(dithDim, dithDim, sizeof(**dithMat));
++        overflow_add(dithDim * sizeof(*dithMat), dithDim * dithDim * sizeof(**dithMat));
+         unsigned int const dithMatSize = 
+             (dithDim * sizeof(*dithMat)) + /* pointers */
+             (dithDim * dithDim * sizeof(**dithMat)); /* data */
+diff --git a/editor/specialty/pamoil.c b/editor/specialty/pamoil.c
+index 6cb8d3a..6f4bde9 100644
+--- a/editor/specialty/pamoil.c
++++ b/editor/specialty/pamoil.c
+@@ -112,6 +112,7 @@ main(int argc, char *argv[] ) {
+     tuples = pnm_readpam(ifp, &inpam, PAM_STRUCT_SIZE(tuple_type));
+     pm_close(ifp);
+ 
++    overflow_add(inpam.maxval, 1);
+     MALLOCARRAY(hist, inpam.maxval + 1);
+     if (hist == NULL)
+         pm_error("Unable to allocate memory for histogram.");
+diff --git a/lib/libpam.c b/lib/libpam.c
+index a8f140b..e6986f1 100644
+--- a/lib/libpam.c
++++ b/lib/libpam.c
+@@ -225,7 +225,8 @@ allocPamRow(const struct pam * const pamP) {
+     unsigned int const bytesPerTuple = allocationDepth(pamP) * sizeof(sample);
+     tuple * tuplerow;
+ 
+-    tuplerow = malloc(pamP->width * (sizeof(tuple *) + bytesPerTuple));
++    overflow_add(sizeof(tuple *), bytesPerTuple);
++    tuplerow = malloc2(pamP->width, (sizeof(tuple *) + bytesPerTuple));
+ 
+     if (tuplerow != NULL) {
+         /* Now we initialize the pointers to the individual tuples
+diff --git a/lib/libpammap.c b/lib/libpammap.c
+index 569156f..bc24d22 100644
+--- a/lib/libpammap.c
++++ b/lib/libpammap.c
+@@ -108,6 +108,8 @@ allocTupleIntListItem(struct pam * const pamP) {
+     */
+     struct tupleint_list_item * retval;
+ 
++    overflow2(pamP->depth, sizeof(sample));
++    overflow_add(sizeof(*retval)-sizeof(retval->tupleint.tuple), pamP->depth*sizeof(sample));
+     unsigned int const size =
+         sizeof(*retval) - sizeof(retval->tupleint.tuple)
+         + pamP->depth * sizeof(sample);
+diff --git a/lib/libpm.c b/lib/libpm.c
+index 47a2f49..a263598 100644
+--- a/lib/libpm.c
++++ b/lib/libpm.c
+@@ -888,5 +888,53 @@ pm_parse_height(const char * const arg) {
+     return height;
+ }
+ 
++/*
++ *	Maths wrapping
++ */
+ 
++void __overflow2(int a, int b)
++{
++        if(a < 0 || b < 0)
++                pm_error("object too large");
++        if(b == 0)
++                return;
++        if(a > INT_MAX / b)
++                pm_error("object too large");
++}
++
++void overflow3(int a, int b, int c)
++{
++        overflow2(a,b);
++        overflow2(a*b, c);
++}
++
++void overflow_add(int a, int b)
++{
++        if( a > INT_MAX - b)
++                pm_error("object too large");
++}
++
++void *malloc2(int a, int b)
++{
++        overflow2(a, b);
++        if(a*b == 0)
++                pm_error("Zero byte allocation");
++        return malloc(a*b);
++}
++
++void *malloc3(int a, int b, int c)
++{
++        overflow3(a, b, c);
++        if(a*b*c == 0)
++                pm_error("Zero byte allocation");
++        return malloc(a*b*c);
++}
++
++void *realloc2(void * a, int b, int c)
++{
++        overflow2(b, c);
++        if(b*c == 0)
++                pm_error("Zero byte allocation");
++        return realloc(a, b*c);
++}
+ 
+diff --git a/lib/pm.h b/lib/pm.h
+index 3fc92fb..17a25f1 100644
+--- a/lib/pm.h
++++ b/lib/pm.h
+@@ -441,5 +441,12 @@ pm_parse_height(const char * const arg);
+ }
+ #endif
+ 
++#define overflow2(a,b) __overflow2(a,b)
++void __overflow2(int, int);
++void overflow3(int, int, int);
++void overflow_add(int, int);
++void *malloc2(int, int);
++void *malloc3(int, int, int);
++void *realloc2(void *, int, int);
+ 
+ #endif
+diff --git a/other/pnmcolormap.c b/other/pnmcolormap.c
+index 7da3122..dafa390 100644
+--- a/other/pnmcolormap.c
++++ b/other/pnmcolormap.c
+@@ -1002,6 +1002,7 @@ colormapToSquare(struct pam * const pamP,
+             pamP->width = intsqrt;
+         else
+             pamP->width = intsqrt + 1;
++            overflow_add(intsqrt, 1);
+     }
+     {
+         unsigned int const intQuotient = colormap.size / pamP->width;
+diff --git a/urt/Runput.c b/urt/Runput.c
+index 3bc562a..cb6e7c5 100644
+--- a/urt/Runput.c
++++ b/urt/Runput.c
+@@ -202,9 +202,11 @@ RunSetup(rle_hdr * the_hdr)
+     if ( the_hdr->background != 0 )
+     {
+ 	register int i;
+-	register rle_pixel *background =
+-	    (rle_pixel *)malloc( (unsigned)(the_hdr->ncolors + 1) );
++	register rle_pixel *background;
+ 	register int *bg_color;
++
++        overflow_add(the_hdr->ncolors,1);
++        background = (rle_pixel *)malloc( (unsigned)(the_hdr->ncolors + 1) );
+ 	/* 
+ 	 * If even number of bg color bytes, put out one more to get to 
+ 	 * 16 bit boundary.
+@@ -224,7 +226,7 @@ RunSetup(rle_hdr * the_hdr)
+ 	/* Big-endian machines are harder */
+ 	register int i, nmap = (1 << the_hdr->cmaplen) *
+ 			       the_hdr->ncmap;
+-	register char *h_cmap = (char *)malloc( nmap * 2 );
++	register char *h_cmap = (char *)malloc2( nmap, 2 );
+ 	if ( h_cmap == NULL )
+ 	{
+ 	    fprintf( stderr,
+diff --git a/urt/rle.h b/urt/rle.h
+index 0071774..6a905ba 100644
+--- a/urt/rle.h
++++ b/urt/rle.h
+@@ -152,6 +152,17 @@ rle_hdr             /* End of typedef. */
+  */
+ extern rle_hdr rle_dflt_hdr;
+ 
++/*
++ * Provided by pm library
++ */
++
++extern void overflow_add(int, int);
++#define overflow2(a,b) __overflow2(a,b)
++extern void __overflow2(int, int);
++extern void overflow3(int, int, int);
++extern void *malloc2(int, int);
++extern void *malloc3(int, int, int);
++extern void *realloc2(void *, int, int);
+ 
+ /* Declare RLE library routines. */
+ 
+diff --git a/urt/rle_addhist.c b/urt/rle_addhist.c
+index b165175..e09ed94 100644
+--- a/urt/rle_addhist.c
++++ b/urt/rle_addhist.c
+@@ -70,13 +70,18 @@ rle_addhist(char *          argv[],
+         return;
+     
+     length = 0;
+-    for (i = 0; argv[i]; ++i)
++    for (i = 0; argv[i]; ++i) {
++        overflow_add(length, strlen(argv[i]));
++        overflow_add(length+1, strlen(argv[i]));
+         length += strlen(argv[i]) +1;   /* length of each arg plus space. */
++    }
+ 
+     time(&temp);
+     timedate = ctime(&temp);
+     length += strlen(timedate);        /* length of date and time in ASCII. */
+-
++    overflow_add(strlen(padding), 4);
++    overflow_add(strlen(histoire), strlen(padding) + 4);
++    overflow_add(length, strlen(histoire) + strlen(padding) + 4);
+     length += strlen(padding) + 3 + strlen(histoire) + 1;
+         /* length of padding, "on "  and length of history name plus "="*/
+     if (in_hdr) /* if we are interested in the old comments... */
+@@ -84,8 +89,10 @@ rle_addhist(char *          argv[],
+     else
+         old = NULL;
+     
+-    if (old && *old)
++    if (old && *old) {
++        overflow_add(length, strlen(old));
+         length += strlen(old);       /* add length if there. */
++    }
+ 
+     ++length;                               /*Cater for the null. */
+ 
+diff --git a/urt/rle_getrow.c b/urt/rle_getrow.c
+index ae220f5..39010ba 100644
+--- a/urt/rle_getrow.c
++++ b/urt/rle_getrow.c
+@@ -164,6 +164,7 @@ rle_get_setup(rle_hdr * const the_hdr) {
+         char * cp;
+ 
+         VAXSHORT(comlen, infile); /* get comment length */
++        overflow_add(comlen, 1);
+         evenlen = (comlen + 1) & ~1;    /* make it even */
+         if (evenlen) {
+             MALLOCARRAY(comment_buf, evenlen);
+diff --git a/urt/rle_hdr.c b/urt/rle_hdr.c
+index 1edb7a3..c3dd60f 100644
+--- a/urt/rle_hdr.c
++++ b/urt/rle_hdr.c
+@@ -148,6 +148,7 @@ rle_hdr_cp(rle_hdr * const fromHdrP,
+     if (toHdrP->cmap) {
+         size_t const size =
+             toHdrP->ncmap * (1 << toHdrP->cmaplen) * sizeof(rle_map);
++        overflow3(toHdrP->ncmap, 1<<toHdrP->cmaplen, sizeof(rle_map));
+         toHdrP->cmap = malloc(size);
+         if (!toHdrP->cmap)
+             pm_error("Failed to allocate memory for %u color maps "
+@@ -163,12 +164,16 @@ rle_hdr_cp(rle_hdr * const fromHdrP,
+         const char ** cp;
+ 
+         /* Count the comments. */
+-        for (cp = toHdrP->comments, size = 0; *cp; ++cp)
++        for (cp = toHdrP->comments, size = 0; *cp; ++cp) {
++            overflow_add(size, 1);
+             ++size;
++        }
+ 
+         /* Check if there are really any comments. */
+         if (size > 0) {
++            overflow_add(size, 1);
+             ++size;     /* Copy the NULL pointer, too. */
++            overflow2(size, sizeof(char *));
+             size *= sizeof(char *);
+             toHdrP->comments = malloc(size);
+             if (!toHdrP->comments)
+diff --git a/urt/rle_open_f.c b/urt/rle_open_f.c
+index 1aeb644..595b15c 100644
+--- a/urt/rle_open_f.c
++++ b/urt/rle_open_f.c
+@@ -163,65 +163,7 @@ dealWithSubprocess(const char *  const file_name,
+                    FILE **       const fpP,
+                    bool *        const noSubprocessP,
+                    const char ** const errorP) {
+-
+-#ifdef NO_OPEN_PIPES
+     *noSubprocessP = TRUE;
+-#else
+-    const char *cp;
+-
+-    reapChildren(catchingChildrenP, pids);
+-
+-    /*  Real file, not stdin or stdout.  If name ends in ".Z",
+-     *  pipe from/to un/compress (depending on r/w mode).
+-     *
+-     *  If it starts with "|", popen that command.
+-     */
+-
+-    cp = file_name + strlen(file_name) - 2;
+-    /* Pipe case. */
+-    if (file_name[0] == '|') {
+-        pid_t thepid;     /* PID from my_popen */
+-
+-        *noSubprocessP = FALSE;
+-
+-        *fpP = my_popen(file_name + 1, mode, &thepid);
+-        if (*fpP == NULL)
+-            *errorP = "%s: can't invoke <<%s>> for %s: ";
+-        else {
+-            /* One more child to catch, eventually. */
+-            if (*catchingChildrenP < MAX_CHILDREN)
+-                pids[(*catchingChildrenP)++] = thepid;
+-        }
+-    } else if (cp > file_name && *cp == '.' && *(cp + 1) == 'Z' ) {
+-        /* Compress case. */
+-        pid_t thepid;     /* PID from my_popen. */
+-        const char * command;
+-
+-        *noSubprocessP = FALSE;
+-
+-        if (*mode == 'w')
+-            pm_asprintf(&command, "compress > %s", file_name);
+-        else if (*mode == 'a')
+-            pm_asprintf(&command, "compress >> %s", file_name);
+-        else
+-            pm_asprintf(&command, "compress -d < %s", file_name);
+-
+-        *fpP = my_popen(command, mode, &thepid);
+-
+-        if (*fpP == NULL)
+-            *errorP = "%s: can't invoke 'compress' program, "
+-                "trying to open %s for %s";
+-        else {
+-            /* One more child to catch, eventually. */
+-            if (*catchingChildrenP < MAX_CHILDREN)
+-                pids[(*catchingChildrenP)++] = thepid;
+-        }
+-        pm_strfree(command);
+-    } else {
+-        *noSubprocessP = TRUE;
+-        *errorP = NULL;
+-    }
+-#endif
+ }
+ 
+ 
+diff --git a/urt/rle_putcom.c b/urt/rle_putcom.c
+index ab2eb20..ce83615 100644
+--- a/urt/rle_putcom.c
++++ b/urt/rle_putcom.c
+@@ -98,12 +98,14 @@ rle_putcom(const char * const value,
+         const char * v;
+         const char ** old_comments;
+         int i;
+-        for (i = 2, cp = the_hdr->comments; *cp != NULL; ++i, ++cp)
++        for (i = 2, cp = the_hdr->comments; *cp != NULL; ++i, ++cp) {
++            overflow_add(i, 1);
+             if (match(value, *cp) != NULL) {
+                 v = *cp;
+                 *cp = value;
+                 return v;
+             }
++        }
+         /* Not found */
+         /* Can't realloc because somebody else might be pointing to this
+          * comments block.  Of course, if this were true, then the
+diff --git a/urt/scanargs.c b/urt/scanargs.c
+index f3af334..8dfa05b 100644
+--- a/urt/scanargs.c
++++ b/urt/scanargs.c
+@@ -62,8 +62,8 @@ typedef int *ptr;
+ /* 
+  * Storage allocation macros
+  */
+-#define NEW( type, cnt )	(type *) malloc( (cnt) * sizeof( type ) )
+-#define RENEW( type, ptr, cnt )	(type *) realloc( ptr, (cnt) * sizeof( type ) )
++#define NEW( type, cnt )	(type *) malloc2( (cnt) , sizeof( type ) )
++#define RENEW( type, ptr, cnt )	(type *) realloc2( ptr, (cnt), sizeof( type ) )
+ 
+ static CONST_DECL char * prformat( CONST_DECL char *, int );
+ static int isnum( CONST_DECL char *, int, int );
+
diff --git a/netpbm-CAN-2005-2471.patch b/netpbm-CAN-2005-2471.patch
index ae17d6b..de6bc59 100644
--- a/netpbm-CAN-2005-2471.patch
+++ b/netpbm-CAN-2005-2471.patch
@@ -1,6 +1,6 @@
 diff -urNp a/converter/other/pstopnm.c b/converter/other/pstopnm.c
---- a/converter/other/pstopnm.c	2018-07-23 15:14:51.200658026 +0200
-+++ b/converter/other/pstopnm.c	2018-07-23 15:18:12.579910612 +0200
+--- a/converter/other/pstopnm.c	2025-02-04 10:47:27.857451432 +0100
++++ b/converter/other/pstopnm.c	2025-02-04 10:55:56.430470597 +0100
 @@ -896,11 +896,11 @@ execGhostscript(int               const
                     ghostscriptProg, arg0,
                     deviceopt, outfileopt, gopt, ropt, textalphabitsopt,
@@ -9,9 +9,9 @@ diff -urNp a/converter/other/pstopnm.c b/converter/other/pstopnm.c
 +                   "-dPARANOIDSAFER", "-");
      }
  
-     execl(ghostscriptProg, arg0, deviceopt, outfileopt, gopt, ropt, 
--	  textalphabitsopt, "-q", "-dNOPAUSE", "-dSAFER", "-", NULL);
-+	  "-q", "-dNOPAUSE", "-dPARANOIDSAFER", "-", NULL);
+     execl(ghostscriptProg, arg0, deviceopt, outfileopt, gopt, ropt,
+-          textalphabitsopt, "-q", "-dNOPAUSE", "-dSAFER", "-", NULL);
++          "-q", "-dNOPAUSE", "-dPARANOIDSAFER", "-", NULL);
  
      pm_error("execl() of Ghostscript ('%s') failed, errno=%d (%s)",
               ghostscriptProg, errno, strerror(errno));
diff --git a/netpbm-c99.patch b/netpbm-c99.patch
index ed0a887..bcb8a99 100644
--- a/netpbm-c99.patch
+++ b/netpbm-c99.patch
@@ -1,46 +1,41 @@
-Include "pm.h" for the declaration of the overflow_add function.  This
-avoids an implicit function declaration.  Future C compilers will
-require that all functions are declared explicitly.  Implicit function
-declarations are a language feature that was removed in 1999.
+Remove the contents of libjasper_compat.c.  The assignment
 
-Likewise, include "pm.h" for the newly added declarations of realloc2.
-This fixes a pointer truncation bug in pjtoppm.
+        *errorP  = errorP;
 
-Both issues are specific to downstream patches.
+is bogus because it creates a non-null value in *errorP even on
+success, and the caller expects a null pointer int his case.
 
-diff --git a/converter/pbm/pbmtoppa/pbm.c b/converter/pbm/pbmtoppa/pbm.c
-index 1c8d236219b297e1..d63cab63b13f2051 100644
---- a/converter/pbm/pbmtoppa/pbm.c
-+++ b/converter/pbm/pbmtoppa/pbm.c
-@@ -12,6 +12,7 @@
- #include <stdlib.h>
- #include <string.h>
- 
-+#include "pm.h"
- #include "ppapbm.h"
- 
- int make_pbm_stat(pbm_stat* pbm,FILE* fptr)
-diff --git a/converter/ppm/pjtoppm.c b/converter/ppm/pjtoppm.c
-index c458c06457c2b9bd..5e93a6acb8d6f198 100644
---- a/converter/ppm/pjtoppm.c
-+++ b/converter/ppm/pjtoppm.c
-@@ -10,6 +10,7 @@
- ** implied warranty.
- */
- 
-+#include "pm.h"
- #include "ppm.h"
- #include "mallocvar.h"
- 
-diff --git a/lib/pm.h b/lib/pm.h
-index 5037c2519c565fbc..435445d5e7f52fbf 100644
---- a/lib/pm.h
-+++ b/lib/pm.h
-@@ -457,6 +457,7 @@ pm_parse_height(const char * const arg);
- 
- void *malloc2(int, int);
- void *malloc3(int, int, int);
-+void *realloc2(void * a, int b, int c);
- #define overflow2(a,b) __overflow2(a,b)
- void __overflow2(int, int);
- void overflow3(int, int, int);
+The source file is compiled, but not actually linked in, so this is
+only a problem because of the type error that fails the build.
+
+diff --git a/converter/other/jpeg2000/libjasper_compat.c b/converter/other/jpeg2000/libjasper_compat.c
+index 101820a321212dc6..e69de29bb2d1d643 100644
+--- a/converter/other/jpeg2000/libjasper_compat.c
++++ b/converter/other/jpeg2000/libjasper_compat.c
+@@ -1,26 +0,0 @@
+-#include "netpbm/nstring.h"
+-
+-#include "jasper/jasper.h"
+-#include "jasper/jas_image.h"
+-
+-#ifndef JAS_HAVE_PMJAS_IMAGE_DECODE
+-
+-void
+-pmjas_image_decode(jas_stream_t * const in,
+-                   int            const fmtArg,
+-                   const char *   const optstr,
+-                   jas_image_t ** const imagePP,
+-                   const char **  const errorP) {
+-
+-    jas_image_t * const jasperP = jas_image_decode(in, fmtArg, optstr);
+-
+-    if (jasperP) {
+-        *imagePP = jasperP;
+-        *errorP  = errorP;
+-    } else {
+-        pm_asprintf(errorP, "Failed.  Details may have been written to "
+-                    "Standard Error");
+-    }
+-}
+-
+-#endif
diff --git a/netpbm-cmuwtopbm.patch b/netpbm-cmuwtopbm.patch
deleted file mode 100644
index f5b328b..0000000
--- a/netpbm-cmuwtopbm.patch
+++ /dev/null
@@ -1,21 +0,0 @@
-diff -up netpbm-10.61.01/converter/pbm/cmuwmtopbm.c.cmuwtopbmfix netpbm-10.61.01/converter/pbm/cmuwmtopbm.c
---- netpbm-10.61.01/converter/pbm/cmuwmtopbm.c.cmuwtopbmfix	2013-01-02 18:39:57.000000000 +0100
-+++ netpbm-10.61.01/converter/pbm/cmuwmtopbm.c	2013-01-03 05:41:36.024984241 +0100
-@@ -18,7 +18,7 @@
-    This program does not check the pad bits at the end of each row.
- */
- 
--
-+#include <stdint.h>
- #include "pbm.h"
- 
- /*--------------------------
-@@ -42,7 +42,7 @@ readCmuwmHeader(FILE *         const ifP
-         "CMU window manager header EOF / read error";
-     uint32_t const cmuwmMagic = 0xf10040bb;
- 
--    long l;
-+    uint32_t l;
-     short s;
-     int rc;
- 
diff --git a/netpbm-glibc.patch b/netpbm-glibc.patch
index 4ae71e8..c500386 100644
--- a/netpbm-glibc.patch
+++ b/netpbm-glibc.patch
@@ -1,9 +1,10 @@
---- netpbm-10.35/converter/other/pnmtotiffcmyk.c.glibc	2006-09-18 12:20:06.000000000 +0200
-+++ netpbm-10.35/converter/other/pnmtotiffcmyk.c	2007-08-23 09:18:30.000000000 +0200
-@@ -974,8 +974,8 @@ int main( int argc, char **argv ) {
+diff -urNp a/converter/other/pnmtotiffcmyk.c b/converter/other/pnmtotiffcmyk.c
+--- a/converter/other/pnmtotiffcmyk.c	2025-02-04 10:47:27.858451429 +0100
++++ b/converter/other/pnmtotiffcmyk.c	2025-02-04 11:04:46.118394226 +0100
+@@ -989,8 +989,8 @@ int main( int argc, char **argv ) {
  
    if ( (err = parseOpts( argc, argv, rt )) ) goto exit ;
-   
+ 
 -  if ( (err = rt->in->open( rt->in, rt )) ) goto exit ;
 -  if ( (err = rt->out->open( rt->out, rt )) ) goto exit ;
 +  if ( (err = (rt->in->open)( rt->in, rt )) ) goto exit ;
diff --git a/netpbm-manfix.patch b/netpbm-manfix.patch
index 10f635d..6d759c1 100644
--- a/netpbm-manfix.patch
+++ b/netpbm-manfix.patch
@@ -1,25 +1,20 @@
 diff -urNp a/userguide/avstopam.html b/userguide/avstopam.html
---- a/userguide/avstopam.html	2022-01-03 16:56:37.731614243 +0100
-+++ b/userguide/avstopam.html	2022-01-03 16:58:29.889416006 +0100
-@@ -2,12 +2,13 @@
+--- a/userguide/avstopam.html	2025-02-04 10:47:27.823451565 +0100
++++ b/userguide/avstopam.html	2025-02-04 17:49:34.981978989 +0100
+@@ -2,9 +2,9 @@
  <html><head><title>Avstopam User Manual</title></head>
  <body>
  <h1>avstopam</h1>
 -Updated: 07 February 2010
 -<br>
 -<a href="#index">Table Of Contents</a>
-+
 +<p>Updated: 07 February 2010</p>
 +
 +<p><a href="#index">Table Of Contents</a></p>
  <h2>NAME</h2>
  
--<p>avstopam - convert an AVS X image to a Netpbm image
-+<p>avstopam - convert an AVS X image to a Netpbm image</p>
- 
- <h2 id="synopsis">SYNOPSIS</h2>
- 
-@@ -16,40 +17,40 @@ Updated: 07 February 2010
+ <p>avstopam - convert an AVS X image to a Netpbm image
+@@ -16,40 +16,40 @@ Updated: 07 February 2010
  
  <h2 id="description">DESCRIPTION</h2>
  
@@ -72,8 +67,8 @@ diff -urNp a/userguide/avstopam.html b/userguide/avstopam.html
  </body>
  </html>
 diff -urNp a/userguide/faxformat.html b/userguide/faxformat.html
---- a/userguide/faxformat.html	2022-01-03 16:56:37.731614243 +0100
-+++ b/userguide/faxformat.html	2022-01-03 16:58:29.890416013 +0100
+--- a/userguide/faxformat.html	2025-02-04 10:47:27.824451560 +0100
++++ b/userguide/faxformat.html	2025-02-04 17:50:41.300631089 +0100
 @@ -5,10 +5,11 @@
  Updated: 03 December 2008
  <br>
@@ -88,8 +83,8 @@ diff -urNp a/userguide/faxformat.html b/userguide/faxformat.html
  (the idea is to provide a way to be sure that a fax machine is able to receive
  a fax sent by another).  These standards incidentally specify graphics file
 diff -urNp a/userguide/libnetpbm_ug.html b/userguide/libnetpbm_ug.html
---- a/userguide/libnetpbm_ug.html	2022-01-03 16:56:37.732614250 +0100
-+++ b/userguide/libnetpbm_ug.html	2022-01-03 16:58:29.891416020 +0100
+--- a/userguide/libnetpbm_ug.html	2025-02-04 10:47:27.824451560 +0100
++++ b/userguide/libnetpbm_ug.html	2025-02-04 17:52:02.045207328 +0100
 @@ -374,7 +374,7 @@ plain format.
  <h2 id="reference">Reference</h2>
  
@@ -100,8 +95,8 @@ diff -urNp a/userguide/libnetpbm_ug.html b/userguide/libnetpbm_ug.html
  
  <p>The <a href="libpm.html">Libnetpbm Utility Manual</a>
 diff -urNp a/userguide/pamfunc.html b/userguide/pamfunc.html
---- a/userguide/pamfunc.html	2022-01-03 16:56:37.730614236 +0100
-+++ b/userguide/pamfunc.html	2022-01-03 16:58:29.892416027 +0100
+--- a/userguide/pamfunc.html	2025-02-04 10:47:27.823451565 +0100
++++ b/userguide/pamfunc.html	2025-02-04 17:52:19.661114878 +0100
 @@ -60,7 +60,7 @@ output image.
  and bit string (such as and with 01001000).  For the arithmetic functions, the
  function arguments and results are the fraction that a sample is of the
@@ -112,9 +107,9 @@ diff -urNp a/userguide/pamfunc.html b/userguide/pamfunc.html
  
  <h4>Arithmetic functions</h4>
 diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
---- a/userguide/pammixmulti.html	2022-01-03 16:56:37.731614243 +0100
-+++ b/userguide/pammixmulti.html	2022-01-03 16:58:29.893416034 +0100
-@@ -7,8 +7,8 @@ Updated: 18 November 2018
+--- a/userguide/pammixmulti.html	2025-02-04 10:47:27.820451577 +0100
++++ b/userguide/pammixmulti.html	2025-02-04 17:56:58.538651212 +0100
+@@ -7,8 +7,8 @@ Updated: 18 December 2024
  <a href="#index">Table Of Contents</a>
    
  
@@ -125,9 +120,15 @@ diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
  
  
  <h2 id="synopsis">SYNOPSIS</h2>
-@@ -22,14 +22,14 @@ Updated: 18 November 2018
- <p>Minimum unique abbreviation of an option is acceptable. You can use a
- single hyphen instead of double hyphens to denote options. You can use white
+@@ -17,19 +17,19 @@ Updated: 18 December 2024
+   [<b>-maskfile</b>=<i>filename</i>]
+   [<b>-stdev</b>=<i>number</i>]
+   [<b>-randomseed</b> <i>integer</i>]
+-  <i>filename</i> ...
++  <i>filename</i> ...</p>
+ 
+ <p>Minimum unique abbreviation of an option is acceptable. You can use double
+ hyphen instead of a single hyphen to denote options. You can use white
  space in place of the equals sign to separate an option name from its
 -value.
 +value.</p>
@@ -151,17 +152,19 @@ diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
 +command line options:</p>
  
  <dl compact>
- <dt><b>--blend</b>=average|random|mask</dt>
-@@ -50,7 +50,7 @@ output is produced by selecting the corr
- images, chosen at random on a per-pixel basis.  With
- <b>--blend</b>=<code>mask</code>, each pixel in the output is produced by a
- weighted average of the corresponding pixels from all the input images based
--on the grayscale level of an additional mask image.
-+on the grayscale level of an additional mask image.</p>
+ <dt><b>-blend</b>=average|alpha-weighted|random|mask</dt>
+@@ -55,8 +55,8 @@ of the input images, chosen at random on
+ With <b>-blend</b>=<code>mask</code>, each pixel in the output is
+ produced by a weighted average of the corresponding pixels from all
+ the input images based on the grayscale level of an additional mask
+-image.
+-<p><b>-alpha-weighted</b> was new in Netpbm 11.09 (December 2024).
++image.</p>
++<p><b>-alpha-weighted</b> was new in Netpbm 11.09 (December 2024).</p>
  </dd>
  
- <dt><b>--maskfile</b>=<i>filename</i></dt>
-@@ -60,7 +60,7 @@ grayscale mask file to control the blend
+ <dt><b>-maskfile</b>=<i>filename</i></dt>
+@@ -66,7 +66,7 @@ grayscale mask file to control the blend
  not grayscale, the first channel is treated as gray).  Where the mask file is
  black, the first image is selected. Where the mask file is white, the last
  image is selected.  Intermediate levels of gray select intermediate
@@ -169,19 +172,19 @@ diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
 +images.</p>
  </dd>
  
- <dt><b>--stdev</b>=<i>number</i></dt>
-@@ -77,7 +77,7 @@ that includes roughly equal amounts of t
+ <dt><b>-stdev</b>=<i>number</i></dt>
+@@ -83,7 +83,7 @@ that includes roughly equal amounts of t
  and 2 but less of the corresponding pixel from image 3.  As <i>number</i>
  tends towards the number of input images (going beyond that has diminishing
  impact), the output tends to look more
--like <b>--blend</b>=average. <i>number</i> defaults to 0.25.
-+like <b>--blend</b>=average. <i>number</i> defaults to 0.25.</p>
+-like <b>-blend</b>=average. <i>number</i> defaults to 0.25.
++like <b>-blend</b>=average. <i>number</i> defaults to 0.25.</p>
  </dd>
  
- <dt><b>--randomseed</b> <i>integer</i>
-@@ -85,45 +85,45 @@ like <b>--blend</b>=average. <i>number</
+ <dt><b>-randomseed</b> <i>integer</i>
+@@ -91,45 +91,45 @@ like <b>-blend</b>=average. <i>number</i
  <dd>This is the seed for the random number generator used with
- <b>--blend=random</b>
+ <b>-blend=random</b>
  
 -<p>Use this to ensure you get the same image on separate invocations.
 +<p>Use this to ensure you get the same image on separate invocations.</p>
@@ -207,7 +210,7 @@ diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
 +image:</p>
  
  <pre><code>
-     pammixmulti --blend=random input*.ppm &gt;output.ppm
+     pammixmulti -blend=random input*.ppm &gt;output.ppm
  </code></pre>
  
  <p>Use a mask image to control the fading among input images on a
@@ -215,7 +218,7 @@ diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
 +pixel-by-pixel basis:</p>
  
  <pre><code>
-     pammixmulti --blend=mask --maskfile=mask.pgm &gt;output.pam \
+     pammixmulti -blend=mask -maskfile=mask.pgm &gt;output.pam \
         one.pam two.pam three.pam four.pam
  </code></pre>
  
@@ -223,7 +226,7 @@ diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
 +<p>Do the same but with more abrupt transitions:</p>
  
  <pre><code>
-     pammixmulti --blend=mask --maskfile=mask.pgm --stdev=0.0 &gt;output.pam \
+     pammixmulti -blend=mask -maskfile=mask.pgm -stdev=0.0 &gt;output.pam \
         one.pam two.pam three.pam four.pam
  </code></pre>
  
@@ -231,8 +234,8 @@ diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
 +<p>and now with more gradual transitions:</p>
  
  <pre><code>
-     pammixmulti --blend=mask --maskfile=mask.pgm --stdev=1.0 &gt;output.pam \
-@@ -133,12 +133,12 @@ pixel-by-pixel basis:
+     pammixmulti -blend=mask -maskfile=mask.pgm -stdev=1.0 &gt;output.pam \
+@@ -139,12 +139,12 @@ pixel-by-pixel basis:
  
  <h2 id="history">HISTORY</h2>
  
@@ -242,12 +245,12 @@ diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
  
  <h2 id="author">AUTHOR</h2>
  
--<p>Copyright 2018 Scott Pakin, scott+pbm@pakin.org.
-+<p>Copyright 2018 Scott Pakin, scott+pbm@pakin.org.</p>
+-<p>Copyright 2018&ndash;2024 Scott Pakin, scott+pbm@pakin.org.
++<p>Copyright 2018&ndash;2024 Scott Pakin, scott+pbm@pakin.org.</p>
  
  <h2 id="seealso">SEE ALSO</h2>
  
-@@ -146,20 +146,20 @@ pixel-by-pixel basis:
+@@ -152,20 +152,20 @@ pixel-by-pixel basis:
  <a href="ppmmix.html">ppmmix</a>,
  <a href="pamarith.html">pamarith</a>,
  <a href="pnm.html">pnm</a>,
@@ -278,8 +281,8 @@ diff -urNp a/userguide/pammixmulti.html b/userguide/pammixmulti.html
  
  </body>
 diff -urNp a/userguide/pampaintspill.html b/userguide/pampaintspill.html
---- a/userguide/pampaintspill.html	2022-01-03 16:56:37.730614236 +0100
-+++ b/userguide/pampaintspill.html	2022-01-03 17:05:08.124277395 +0100
+--- a/userguide/pampaintspill.html	2025-02-04 10:47:27.823451565 +0100
++++ b/userguide/pampaintspill.html	2025-02-04 18:01:50.746117598 +0100
 @@ -7,7 +7,7 @@ Updated: 02 November 2021
  <a href="#index">Table Of Contents</a>
  
@@ -289,7 +292,7 @@ diff -urNp a/userguide/pampaintspill.html b/userguide/pampaintspill.html
  
  <h2 id="synopsis">SYNOPSIS</h2>
  
-@@ -19,17 +19,17 @@ pampaintspill - smoothly spill colors in
+@@ -19,48 +19,48 @@ pampaintspill - smoothly spill colors in
  [<b>--downsample</b>=<i>number</i>]
  [<b>--near</b>=<i>number</i>]
  [<b>--power</b>=<i>number</i>] [<i>filename</i>]
@@ -310,7 +313,11 @@ diff -urNp a/userguide/pampaintspill.html b/userguide/pampaintspill.html
  
  <p><b>pampaintspill</b> produces a smooth color gradient from all of the
  non-background-colored pixels in an input image, effectively "spilling
-@@ -40,27 +40,27 @@ paint" onto the background.  <b>pampaint
+ paint" onto the background.  <b>pampaintspill</b> is similar to
+-<b>pamgradient</b> but differs in the following characteristics:
++<b>pamgradient</b> but differs in the following characteristics:</p>
+ 
+ <ul>
    <li><b>pampaintspill</b> accepts any number of paint
        sources (non-background-colored pixels), which can lie anywhere
        on the canvas.  <b>pamgradient</b> accepts exactly
@@ -343,14 +350,13 @@ diff -urNp a/userguide/pampaintspill.html b/userguide/pampaintspill.html
  
  <dl>
    <dt><b>--bgcolor</b>=<i>color</i></dt>
-@@ -116,46 +116,46 @@ command line options:
-       2.0) make the paint sources stand out in the output image by pushing the
+@@ -117,45 +117,45 @@ command line options:
        gradients away from them.</dd>
  
--  <dt><b>-randomseed=</b><i>integer</i>
-+  <dt><b>-randomseed=</b><i>integer</i></dt>
-   <dd>This is the seed for the random number generator that generates the
+   <dt><b>-randomseed=</b><i>integer</i>
+-  <dd>This is the seed for the random number generator that generates the
 -  pixels.
++  <dd>This is the seed fodr the random number generator that generates the
 +  pixels.</dd>
  
 -  <p>Use this to ensure you get the same image on separate invocations.
@@ -409,8 +415,8 @@ diff -urNp a/userguide/pampaintspill.html b/userguide/pampaintspill.html
  
  </body>
 diff -urNp a/userguide/pamrecolor.html b/userguide/pamrecolor.html
---- a/userguide/pamrecolor.html	2022-01-03 16:56:37.731614243 +0100
-+++ b/userguide/pamrecolor.html	2022-01-03 16:58:29.894416041 +0100
+--- a/userguide/pamrecolor.html	2025-02-04 10:47:27.823451565 +0100
++++ b/userguide/pamrecolor.html	2025-02-04 18:10:00.968545076 +0100
 @@ -2,9 +2,9 @@
  <html><head><title>Pamrecolor User Manual</title></head>
  <body>
@@ -472,6 +478,15 @@ diff -urNp a/userguide/pamrecolor.html b/userguide/pamrecolor.html
  
  <dl>
  
+@@ -67,7 +67,7 @@ to luminance of each of the red, green,
+ example, in the SMPTE-C color space an RGB color is converted to
+ grayscale by multiplying the red channel by 0.2124132, the green
+ channel by 0.7010437, and the blue channel by 0.0865432 and summing
+-the resulting three products.
++the resulting three products.</dd>
+ 
+ <p>When you use this option, the input and output images are not true Netpbm
+ images, because the Netpbm image format specifies a particular color space.
 @@ -76,9 +76,9 @@ the raster have different meaning.  Many
  images actually use a variation with a different color space.  For example,
  <a href="http://www.gimp.org/">GIMP</a> uses sRGB internally and if you
@@ -484,7 +499,7 @@ diff -urNp a/userguide/pamrecolor.html b/userguide/pamrecolor.html
  
    <dl>
    <dt>adobe</dt>
-@@ -109,7 +109,7 @@ the format that uses sRGB.
+@@ -109,12 +109,12 @@ the format that uses sRGB.
  <p>The default is "ntsc" because this is the color space that the Netpbm
  formats and many graphics utilities use.  As a counterexample,
  <a href="http://www.gimp.org/">GIMP</a> uses sRGB as its native color
@@ -493,18 +508,172 @@ diff -urNp a/userguide/pamrecolor.html b/userguide/pamrecolor.html
  
  <p>The luminance values <b>pamrecolor</b> uses for each of the above come from
  Bruce Lindbloom's
-diff -urNp a/userguide/pbmtog3.html b/userguide/pbmtog3.html
---- a/userguide/pbmtog3.html	2022-01-03 16:56:37.732614250 +0100
-+++ b/userguide/pbmtog3.html	2022-01-03 16:58:29.894416041 +0100
-@@ -36,7 +36,7 @@ use those encodings.
- <p>In addition to the options common to all programs based on libnetpbm
- (most notably <b>-quiet</b>, see <a href="index.html#commonoptions">
- Common Options</a>), <b>pbmtog3</b> recognizes the following
--command line options:
-+command line options:</p>
+ <a href="http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html">
+-Computing RGB-to-XYZ and XYZ-to-RGB matrices</a> page.</dd>
++Computing RGB-to-XYZ and XYZ-to-RGB matrices</a> page.</p>
  
- <dl>
- <dt><b>-reversebits</b>
+ <dt><b>--rmult</b>=<i>fraction</i></dt>
+ <dt><b>--gmult</b>=<i>fraction</i></dt>
+@@ -133,15 +133,13 @@ image.  <b>pamrecolor</b> will make each
+ to <i>color</i> subject to the constraint that the luminance must stay the
+ same as in the original image.  Specify <i>color</i> as in
+ the <a href="libnetpbm_image.html#colorname">argument of the <b>pnm_parsecolor()</b>
+-library routine</a> (e.g.,&nbsp;"hotpink" or "#ff69b4").
++library routine</a> (e.g.,&nbsp;"hotpink" or "#ff69b4").</dd>
+ 
+ <p>If you specify neither <b>--targetcolor</b> nor
+ <b>--colorfile</b>, <b>pamrecolor</b> will randomly select a target color for
+-each pixel of the input image.
+-
+-<p>You may not specify both <b>-targetcolor</b> and <b>-colorfile</b>.
++each pixel of the input image.</p>
+ 
+-</dd>
++<p>You may not specify both <b>-targetcolor</b> and <b>-colorfile</b>.</p>
+ 
+ <dt><b>--colorfile</b>=<i>file</i></dt>
+ <dd>Take per-pixel target colors from Netpbm file <i>file</i> instead
+@@ -150,40 +148,38 @@ of using a single target color for the e
+ If the image in the file wider or taller than the input image,
+ <b>pamrecolor</b> uses only the left and top part of it.
+ If the image is narrower or shorter, <b>pamrecolor</b> considers the
+-image to be repeated in a tile pattern.
++image to be repeated in a tile pattern.</dd>
+ 
+ <p>If you specify neither <b>--targetcolor</b> nor
+ <b>--colorfile</b>, <b>pamrecolor</b> will randomly select a target color for
+-each pixel of the input image.
++each pixel of the input image.</p>
+ 
+-<p>You may not specify both <b>-targetcolor</b> and <b>-colorfile</b>.
++<p>You may not specify both <b>-targetcolor</b> and <b>-colorfile</b>.</p>
+ 
+-<dt><b>-randomseed=</b><i>integer</i>
++<dt><b>-randomseed=</b><i>integer</i></dt>
+ 
+ <dd>This is the seed for the random number generator that generates the
+-pixels.
++pixels.</dd>
+ 
+-<p>Use this to ensure you get the same image on separate invocations.
++<p>Use this to ensure you get the same image on separate invocations.</p>
+ 
+ <p>By default, <b>pamrecolor</b> uses a seed derived from the time of day
+ and process ID, which gives you fairly uncorrelated results in multiple
+-invocations.
+-
+-<p>This option was new in Netpbm 10.61 (December 2012).
++invocations.</p>
+ 
+-</dl>
++<p>This option was new in Netpbm 10.61 (December 2012).</p>
+ 
+ 
+ <h2 id="examples">EXAMPLES</h2>
+ 
+-<p>This command tints an image yellow:
++<p>This command tints an image yellow:</p>
+ 
+ <pre>
+     pamrecolor --targetcolor=yellow colorpic.pam &gt; yellowpic.pam
+ </pre>
+ 
+ <p>This command takes the colors from <b>colorpicture.ppm</b> and applies
+-them to <b>graypicture.pgm</b>:
++them to <b>graypicture.pgm</b>:</p>
+ 
+ <pre>
+     pamrecolor --colorfile=colorpic.ppm graypic.pgm &gt; colorizedpic.pam
+@@ -192,52 +188,52 @@ them to <b>graypicture.pgm</b>:
+ <p>The grayscale version of <b>colorizedpic.pam</b> will look just like
+ graypic.pgm.  Note that if you use a non-Netpbm tool to do the conversion to
+ grayscale, you may additionally need to specify an
+-appropriate <b>--colorspace</b> value for your conversion tool.
++appropriate <b>--colorspace</b> value for your conversion tool.</p>
+ 
+ 
+ <h2 id="notes">NOTES</h2>
+ 
+ <p>Here are a couple of fun special effects you can produce with
+-<b>pamrecolor</b>:
++<b>pamrecolor</b>:</p>
+ 
+ <ul>
+ <li>Specify a color file that is identical to the input image but with
+ some large, colored text added to it.  The text will "magically"
+-vanish when the image is converted to grayscale.
++vanish when the image is converted to grayscale.</li>
+ 
+ <li>Provide a low-contrast grayscale image &mdash; perhaps a secret
+ message written in similar shades of gray &mdash; as the input file and
+ a colorful but completely different image as the color file.  If done
+ carefully, the grayscale image can be hidden by the colorful image.
+ Only people who know to convert the result to grayscale can recover
+-the original grayscale image.
++the original grayscale image.</li>
+ 
+ <li>Use <b>--targetcolor</b>=tan to make an image look like an
+ old-timey photograph (or, more precisely, a
+ <a href="http://en.wikipedia.org/wiki/Photographic_print_toning">sepia-toned
+-photograph</a> of the late 1800s).
++photograph</a> of the late 1800s).</li>
+ </ul>
+ 
+ 
+ <h2 id="history">HISTORY</h2>
+ 
+-<p>Scott Pakin wrote <b>pamrecolor</b> in July 2010.
++<p>Scott Pakin wrote <b>pamrecolor</b> in July 2010.</p>
+ 
+-<p><b>pamrecolor</b> was new in Netpbm 10.52 (September 2010).
++<p><b>pamrecolor</b> was new in Netpbm 10.52 (September 2010).</p>
+ 
+ 
+ <h2 id="author">AUTHOR</h2>
+ 
+ <p>Copyright (C) 2010 Scott
+-Pakin, <a href="mailto:scott+pbm@pakin.org">scott+pbm@pakin.org</a>
++Pakin, <a href="mailto:scott+pbm@pakin.org">scott+pbm@pakin.org</a></p>
+ 
+ 
+ <h2 id="seealso">SEE ALSO</h2>
+ 
+ <ul>
+-<li><a href="ppmtopgm.html"><b>ppmtopgm</b></a>
+-<li><a href="ppmchange.html"><b>ppmchange</b></a>
+-<li><a href="pnmremap.html"><b>pnmremap</b></a>
++<li><a href="ppmtopgm.html"><b>ppmtopgm</b></a></li>
++<li><a href="ppmchange.html"><b>ppmchange</b></a></li>
++<li><a href="pnmremap.html"><b>pnmremap</b></a></li>
+ </ul>
+ 
+ 
+@@ -246,14 +242,14 @@ Pakin, <a href="mailto:scott+pbm@pakin.o
+ <h2 id="index">Table Of Contents</h2>
+ 
+ <ul>
+-<li><a href="#synopsis">SYNOPSIS</a>
+-<li><a href="#description">DESCRIPTION</a>
+-<li><a href="#options">OPTIONS</a>
+-<li><a href="#examples">EXAMPLES</a>
+-<li><a href="#notes">NOTES</a>
+-<li><a href="#history">HISTORY</a>
+-<li><a href="#author">AUTHOR</a>
+-<li><a href="#seealso">SEE ALSO</a>
++<li><a href="#synopsis">SYNOPSIS</a></li>
++<li><a href="#description">DESCRIPTION</a></li>
++<li><a href="#options">OPTIONS</a></li>
++<li><a href="#examples">EXAMPLES</a></li>
++<li><a href="#notes">NOTES</a></li>
++<li><a href="#history">HISTORY</a></li>
++<li><a href="#author">AUTHOR</a></li>
++<li><a href="#seealso">SEE ALSO</a></li>
+ </ul>
+ 
+ </body>
+diff -urNp a/userguide/pbmtog3.html b/userguide/pbmtog3.html
+--- a/userguide/pbmtog3.html	2025-02-04 10:47:27.827451549 +0100
++++ b/userguide/pbmtog3.html	2025-02-04 18:10:55.328259786 +0100
 @@ -80,7 +80,7 @@ You cannot specify both.
  <h2 id="history">HISTORY</h2>
  
@@ -515,8 +684,8 @@ diff -urNp a/userguide/pbmtog3.html b/userguide/pbmtog3.html
  and then modified extensively by others.
  
 diff -urNp a/userguide/ppmtogif.html b/userguide/ppmtogif.html
---- a/userguide/ppmtogif.html	2022-01-03 16:56:37.733614257 +0100
-+++ b/userguide/ppmtogif.html	2022-01-03 16:58:29.895416049 +0100
+--- a/userguide/ppmtogif.html	2025-02-04 10:47:27.828451545 +0100
++++ b/userguide/ppmtogif.html	2025-02-04 18:12:39.950710820 +0100
 @@ -5,17 +5,17 @@
  
  <h2>NAME</h2>
diff --git a/netpbm-ppmfadeusage.patch b/netpbm-ppmfadeusage.patch
index d48f5f5..2943ddb 100644
--- a/netpbm-ppmfadeusage.patch
+++ b/netpbm-ppmfadeusage.patch
@@ -1,57 +1,62 @@
-diff -urNp old/editor/ppmfade new/editor/ppmfade
---- old/editor/ppmfade	2017-11-01 11:47:49.869611402 +0100
-+++ new/editor/ppmfade	2017-11-01 11:53:25.524973342 +0100
-@@ -84,7 +84,7 @@ for ($n = 0; $n < @ARGV; $n++) {
-         if (-e $first_file) {
+diff -urNp a/editor/ppmfade b/editor/ppmfade
+--- a/editor/ppmfade	2025-02-04 10:47:27.812451607 +0100
++++ b/editor/ppmfade	2025-02-04 10:52:14.233336029 +0100
+@@ -99,6 +99,9 @@ sub commandLineArgs() {
+             $mode = 'BLOCK';
+         } elsif ($arg eq "-mix") {
+             $mode = 'MIX';
++        } elsif ($arg eq "-help" || $arg eq "--help" || $arg eq "-h") {
++            print STDERR ("ppmfade: Use 'man ppmfade' for help.\n");
++            exit 1;
          } else {
-             print "I can't find first file '$first_file'\n";
--            exit 20;
+             if (substr($arg, 0, 1) eq '-') {
+                    print STDERR ("Unknown option '$arg'.  " .
+@@ -109,13 +112,13 @@ sub commandLineArgs() {
+                 print STDERR ("There are no non-option arguments possible.  " .
+                               "You specified '$arg'\n");
+             }
+-            exit 100;
 +            exit 1;
          }
-     } elsif ($ARGV[$n] eq "-l") {
-         $n++;
-@@ -92,7 +92,7 @@ for ($n = 0; $n < @ARGV; $n++) {
-         if (-e $last_file) {
+     }
+ 
+     if (!defined($firstFileNm) && !defined($lastFileNm)) {
+         print STDERR ("You must specify -f or -l (or both)\n");
+-        exit 90;
++        exit 1
+     }
+ 
+     if (!defined($mode)) {
+@@ -142,7 +145,7 @@ sub imageDimensions($$) {
          } else {
-             print "I can't find last file '$last_file'\n";
--            exit 20;
-+            exit 1;
+             print STDERR
+                 ("Unrecognized results from pnmfile on $firstFileNm.\n");
+-            exit(50);
++            exit(1);
          }
-     } elsif ($ARGV[$n] eq "-base") {
-         $n++;
-@@ -113,9 +113,12 @@ for ($n = 0; $n < @ARGV; $n++) {
-         $mode = $BLOCK;
-     } elsif ("$ARGV[$n]" eq "-mix") {
-         $mode = $MIX;
-+    } elsif ($ARGV[$n] eq "-help" || $ARGV[$n] eq "--help" || $ARGV[$n] eq "-h") {
-+        print "ppmfade: Use 'man ppmfade' for help.\n";
-+        exit 1;
      } else {
-         print "Unknown argument: $ARGV[$n]\n";
--        exit 100;
-+        exit 1;
-     } 
- }
- #
-@@ -134,18 +137,18 @@ if ($first_file ne "undefined") {
-         $width = $1; $height = $2;
-     } else {
-         print("Unrecognized results from pnmfile on $first_file.\n");
--        exit(50);
-+        exit 1;
+         # $lastFileNm is defined
+@@ -151,7 +154,7 @@ sub imageDimensions($$) {
+         } else {
+             print STDERR
+                 ("Unrecognized results from pnmfile on $firstFileNm.\n");
+-            exit(50);
++            exit(1);
+         }
      }
- } elsif ($last_file ne "undefined") {
-     if ((`pnmfile $last_file` =~ m{\b(\d+)\sby\s(\d+)} )) { 
-         $width = $1; $height = $2;
-     } else {
-         print("Unrecognized results from pnmfile on $first_file.\n");
--        exit(50);
-+        exit 1;
-     }
- } else {
-     print("ppmfade:  You must specify -f or -l (or both)\n");
--    exit(90);
+     return $width, $height;
+@@ -436,12 +439,12 @@ my ($mode, $firstFileNm, $lastFileNm, $b
+ 
+ if (defined($firstFileNm) && !-e($firstFileNm)) {
+     print STDERR ("First file '$firstFileNm' does not exist\n");
+-    exit 20;
 +    exit 1;
  }
  
- print("Frames are " . $width . "W x " . $height . "H\n");
+ if (defined($lastFileNm) && !-e($lastFileNm)) {
+     print STDERR ("Last file '$lastFileNm' does not exist\n");
+-    exit 20;
++    exit 1;
+ }
+ 
+ my ($width, $height) = imageDimensions($firstFileNm, $lastFileNm);
diff --git a/netpbm-security-code.patch b/netpbm-security-code.patch
index 75c66e5..d7daa7f 100644
--- a/netpbm-security-code.patch
+++ b/netpbm-security-code.patch
@@ -1,45 +1,49 @@
-diff -ruNp a/analyzer/pgmtexture.c b/analyzer/pgmtexture.c
---- a/analyzer/pgmtexture.c	2021-06-02 15:53:59.866205957 +0200
-+++ b/analyzer/pgmtexture.c	2021-06-02 16:13:04.906252648 +0200
-@@ -54,6 +54,7 @@ vector(unsigned int const nl,
+diff -urNp a/analyzer/pgmtexture.c b/analyzer/pgmtexture.c
+--- a/analyzer/pgmtexture.c	2025-02-03 09:24:28.362500390 +0100
++++ b/analyzer/pgmtexture.c	2025-02-03 09:27:57.991369817 +0100
+@@ -97,6 +97,8 @@ vector(unsigned int const nl,
  
-     assert(nh >= nl);
+     assert(nh >= nl); assert(nh <= UINT_MAX-1);
  
 +    overflow_add(nh - nl, 1);
++
      MALLOCARRAY(v, (unsigned) (nh - nl + 1));
  
      if (v == NULL)
-@@ -85,6 +86,7 @@ matrix (unsigned int const nrl,
-     assert(nrh >= nrl);
+@@ -133,6 +135,8 @@ matrix (unsigned int const nrl,
+ 
+     assert(nrh >= nrl); assert(nrh <= UINT_MAX-1);
  
-     /* allocate pointers to rows */
 +    overflow_add(nrh - nrl, 1);
-     MALLOCARRAY(m, (unsigned) (nrh - nrl + 1));
-     if (m == NULL)
-         pm_error("Unable to allocate memory for a matrix.");
-@@ -93,6 +95,7 @@ matrix (unsigned int const nrl,
++
+     /* allocate pointers to rows */
+     MALLOCARRAY(matrix, (unsigned) (nrh - nrl + 1));
+     if (matrix == NULL)
+@@ -142,6 +146,8 @@ matrix (unsigned int const nrl,
  
-     assert (nch >= ncl);
+     assert (nch >= ncl); assert(nch <= UINT_MAX-1);
  
 +    overflow_add(nch - ncl, 1);
++
      /* allocate rows and set pointers to them */
      for (i = nrl; i <= nrh; ++i) {
-         MALLOCARRAY(m[i], (unsigned) (nch - ncl + 1));
-diff -ruNp a/converter/other/gemtopnm.c b/converter/other/gemtopnm.c
---- a/converter/other/gemtopnm.c	2021-06-02 15:53:59.835205659 +0200
-+++ b/converter/other/gemtopnm.c	2021-06-02 16:15:29.598641385 +0200
-@@ -106,6 +106,7 @@ main(argc, argv)
+         MALLOCARRAY(matrix[i], (unsigned) (nch - ncl + 1));
+diff -urNp a/converter/other/gemtopnm.c b/converter/other/gemtopnm.c
+--- a/converter/other/gemtopnm.c	2025-02-03 09:24:28.345500482 +0100
++++ b/converter/other/gemtopnm.c	2025-02-03 09:28:49.455092222 +0100
+@@ -153,6 +153,8 @@ main(int argc, const char ** argv) {
  
-     pnm_writepnminit( stdout, cols, rows, MAXVAL, type, 0 );
+     pnm_writepnminit(stdout, cols, rows, MAXVAL, type, 0);
  
 +    overflow_add(cols, padright);
++
      {
          /* allocate input row data structure */
-         int plane;
-diff -ruNp a/converter/other/jpegtopnm.c b/converter/other/jpegtopnm.c
---- a/converter/other/jpegtopnm.c	2021-06-02 15:53:59.833205640 +0200
-+++ b/converter/other/jpegtopnm.c	2021-06-02 16:16:28.520206914 +0200
-@@ -862,6 +862,8 @@ convertImage(FILE *
+         unsigned int plane;
+diff -urNp a/converter/other/jpegtopnm.c b/converter/other/jpegtopnm.c
+--- a/converter/other/jpegtopnm.c	2025-02-03 09:24:28.346500477 +0100
++++ b/converter/other/jpegtopnm.c	2025-02-03 09:29:57.845723398 +0100
+@@ -894,6 +894,8 @@ convertImage(FILE *
      /* Calculate output image dimensions so we can allocate space */
      jpeg_calc_output_dimensions(cinfoP);
  
@@ -48,21 +52,21 @@ diff -ruNp a/converter/other/jpegtopnm.c b/converter/other/jpegtopnm.c
      /* Start decompressor */
      jpeg_start_decompress(cinfoP);
  
-diff -ruNp a/converter/other/pbmtopgm.c b/converter/other/pbmtopgm.c
---- a/converter/other/pbmtopgm.c	2021-06-02 15:53:59.831205621 +0200
-+++ b/converter/other/pbmtopgm.c	2021-06-02 16:17:14.248645808 +0200
-@@ -60,6 +60,7 @@ main(int argc, char *argv[]) {
- 
+diff -urNp a/converter/other/pbmtopgm.c b/converter/other/pbmtopgm.c
+--- a/converter/other/pbmtopgm.c	2025-02-03 09:24:28.346500477 +0100
++++ b/converter/other/pbmtopgm.c	2025-02-03 09:32:07.478024266 +0100
+@@ -88,6 +88,7 @@ main(int argc, const char ** argv) {
+     up   = cmdline.convRows / 2;  down  = cmdline.convRows - up;
  
      outrow = pgm_allocrow(cols) ;
-+    overflow2(width, height);
-     maxval = MIN(PGM_OVERALLMAXVAL, width*height);
++    overflow2(cmdline.convCols, cmdline.convRows);
+     maxval = MIN(PGM_OVERALLMAXVAL, cmdline.convCols * cmdline.convRows);
      pgm_writepgminit(stdout, cols, rows, maxval, 0) ;
  
-diff -ruNp a/converter/other/pnmtoddif.c b/converter/other/pnmtoddif.c
---- a/converter/other/pnmtoddif.c	2021-06-02 15:53:59.832205630 +0200
-+++ b/converter/other/pnmtoddif.c	2021-06-02 16:18:17.064248709 +0200
-@@ -629,6 +629,7 @@ main(int argc, char *argv[]) {
+diff -urNp a/converter/other/pnmtoddif.c b/converter/other/pnmtoddif.c
+--- a/converter/other/pnmtoddif.c	2025-02-03 09:24:28.346500477 +0100
++++ b/converter/other/pnmtoddif.c	2025-02-03 09:33:21.228626549 +0100
+@@ -627,6 +627,7 @@ main(int argc, char *argv[]) {
      switch (PNM_FORMAT_TYPE(format)) {
      case PBM_TYPE:
          ip.bits_per_pixel = 1;
@@ -70,7 +74,7 @@ diff -ruNp a/converter/other/pnmtoddif.c b/converter/other/pnmtoddif.c
          ip.bytes_per_line = (cols + 7) / 8;
          ip.spectral = 2;
          ip.components = 1;
-@@ -644,6 +645,7 @@ main(int argc, char *argv[]) {
+@@ -642,6 +643,7 @@ main(int argc, char *argv[]) {
          ip.polarity = 2;
          break;
      case PPM_TYPE:
@@ -78,146 +82,100 @@ diff -ruNp a/converter/other/pnmtoddif.c b/converter/other/pnmtoddif.c
          ip.bytes_per_line = 3 * cols;
          ip.bits_per_pixel = 24;
          ip.spectral = 5;
-diff -ruNp a/converter/other/pnmtojpeg.c b/converter/other/pnmtojpeg.c
---- a/converter/other/pnmtojpeg.c	2021-06-02 15:53:59.835205659 +0200
-+++ b/converter/other/pnmtojpeg.c	2021-06-02 19:57:44.413225834 +0200
-@@ -606,7 +606,11 @@ read_scan_script(j_compress_ptr const ci
-            want JPOOL_PERMANENT.
-         */
-         const unsigned int scan_info_size = nscans * sizeof(jpeg_scan_info);
--        jpeg_scan_info * const scan_info =
-+        const jpeg_scan_info * scan_info;
-+
-+        overflow2(nscans, sizeof(jpeg_scan_info));
-+
-+        scan_info =
-             (jpeg_scan_info *)
-             (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                                         scan_info_size);
-@@ -938,6 +942,9 @@ compute_rescaling_array(JSAMPLE ** const
-   const long half_maxval = maxval / 2;
-   long val;
+diff -urNp a/converter/other/pnmtops.c b/converter/other/pnmtops.c
+--- a/converter/other/pnmtops.c	2025-02-03 09:24:28.345500482 +0100
++++ b/converter/other/pnmtops.c	2025-02-03 09:42:01.586878661 +0100
+@@ -298,17 +298,21 @@ parseCommandLine(int argc, const char **
+     validateCompDimension(width,  psScaleFactor, "-width value");
+     validateCompDimension(height, psScaleFactor, "-height value");
  
-+  overflow_add(maxval, 1);
-+  overflow2(maxval+1, sizeof(JSAMPLE));
-+
-   *rescale_p = (JSAMPLE *)
-     (cinfo.mem->alloc_small) ((j_common_ptr) &cinfo, JPOOL_IMAGE,
-                               (size_t) (((long) maxval + 1L) *
-@@ -1016,6 +1023,7 @@ convert_scanlines(struct jpeg_compress_s
-     */
- 
-   /* Allocate the libpnm output and compressor input buffers */
-+  overflow2(cinfo_p->image_width, cinfo_p->input_components);
-   buffer = (*cinfo_p->mem->alloc_sarray)
-     ((j_common_ptr) cinfo_p, JPOOL_IMAGE,
-      (unsigned int) cinfo_p->image_width * cinfo_p->input_components,
-diff -ruNp a/converter/other/pnmtops.c b/converter/other/pnmtops.c
---- a/converter/other/pnmtops.c	2021-06-02 15:53:59.835205659 +0200
-+++ b/converter/other/pnmtops.c	2021-06-02 20:02:06.055502227 +0200
-@@ -294,17 +294,21 @@ parseCommandLine(int argc, const char **
-     validateCompDimension(width, 72, "-width value");
-     validateCompDimension(height, 72, "-height value");
- 
-+    overflow2(width, 72);
-     cmdlineP->width  = width * 72;
-+    overflow2(height, 72);
-     cmdlineP->height = height * 72;
++    overflow2(width, psScaleFactor);
+     cmdlineP->width  = width  * psScaleFactor;
++    overflow2(height, psScaleFactor);
+     cmdlineP->height = height * psScaleFactor;
  
      if (imagewidthSpec) {
-         validateCompDimension(imagewidth, 72, "-imagewidth value");
-+        overflow2(imagewidth, 72);
-         cmdlineP->imagewidth = imagewidth * 72;
+         validateCompDimension(imagewidth, psScaleFactor, "-imagewidth value");
++        overflow2(imagewidth, psScaleFactor);
+         cmdlineP->imagewidth = imagewidth * psScaleFactor;
      }
      else
          cmdlineP->imagewidth = 0;
      if (imageheightSpec) {
--        validateCompDimension(imagewidth, 72, "-imageheight value");
-+        validateCompDimension(imageheight, 72, "-imageheight value");
-+        overflow2(imageheight, 72);
-         cmdlineP->imageheight = imageheight * 72;
+-        validateCompDimension(imagewidth, psScaleFactor, "-imageheight value");
++        validateCompDimension(imageheight, psScaleFactor, "-imageheight value");
++        overflow2(imageheight, psScaleFactor);
+         cmdlineP->imageheight = imageheight * psScaleFactor;
      }
      else
-diff -ruNp a/converter/other/rletopnm.c b/converter/other/rletopnm.c
---- a/converter/other/rletopnm.c	2021-06-02 15:53:59.834205650 +0200
-+++ b/converter/other/rletopnm.c	2021-06-02 20:03:24.864187893 +0200
-@@ -19,6 +19,8 @@
-  * If you modify this software, you should include a notice giving the
-  * name of the person performing the modification, the date of modification,
-  * and the reason for such modification.
-+ *
-+ * 2002-12-19: Fix maths wrapping bugs. Alan Cox <alan@redhat.com>
-  */
- /*
-  * rletopnm - A conversion program to convert from Utah's "rle" image format
-diff -ruNp a/converter/other/sirtopnm.c b/converter/other/sirtopnm.c
---- a/converter/other/sirtopnm.c	2021-06-02 15:53:59.833205640 +0200
-+++ b/converter/other/sirtopnm.c	2021-06-02 20:03:50.280409024 +0200
-@@ -69,6 +69,7 @@ char* argv[];
- 	    }
- 	    break;
- 	case PPM_TYPE:
-+        overflow3(cols, rows, 3);
- 	    picsize = cols * rows * 3;
- 	    planesize = cols * rows;
-             if ( !( sirarray = (unsigned char*) malloc( picsize ) ) ) 
-diff -ruNp a/converter/other/tifftopnm.c b/converter/other/tifftopnm.c
---- a/converter/other/tifftopnm.c	2021-06-02 15:53:59.834205650 +0200
-+++ b/converter/other/tifftopnm.c	2021-06-02 20:04:47.721908789 +0200
-@@ -1372,7 +1372,9 @@ convertRasterByRows(pnmOut *       const
-     if (scanbuf == NULL)
-         pm_error("can't allocate memory for scanline buffer");
+diff -urNp a/converter/other/sirtopnm.c b/converter/other/sirtopnm.c
+--- a/converter/other/sirtopnm.c	2025-02-03 09:24:28.347500471 +0100
++++ b/converter/other/sirtopnm.c	2025-02-03 09:44:25.547151413 +0100
+@@ -84,6 +84,7 @@ convertPpm(FILE *       const ifP,
+            unsigned int const cols,
+            xel *        const xelrow) {
  
++    overflow3(cols, rows, 3);
+     unsigned int const picsize = cols * rows * 3;
+     unsigned int const planesize = cols * rows;
+ 
+diff -urNp a/converter/other/tifftopnm.c b/converter/other/tifftopnm.c
+--- a/converter/other/tifftopnm.c	2025-02-03 09:24:28.345500482 +0100
++++ b/converter/other/tifftopnm.c	2025-02-03 09:46:55.210395347 +0100
+@@ -1358,7 +1358,8 @@ convertRasterByRows(pnmOut *       const
+     if (UINT_MAX/cols < spp)
+         pm_error("Image is too wide/deep (%u x %u) for computations",
+                  cols, spp);
 -    MALLOCARRAY(samplebuf, cols * spp);
 +    /* samplebuf is unsigned int * !!! */
-+    samplebuf = (unsigned int *) malloc3(cols , sizeof(unsigned int) , spp);
-+
++    samplebuf = (unsigned int *) malloc3(cols, sizeof(unsigned int), spp);
      if (samplebuf == NULL)
          pm_error("can't allocate memory for row buffer");
  
-diff -ruNp a/converter/other/xwdtopnm.c b/converter/other/xwdtopnm.c
---- a/converter/other/xwdtopnm.c	2021-06-02 15:53:59.833205640 +0200
-+++ b/converter/other/xwdtopnm.c	2021-06-02 20:23:21.807634239 +0200
-@@ -210,6 +210,10 @@ processX10Header(X10WDFileHeader *  cons
-         *colorsP = pnm_allocrow(2);
-         PNM_ASSIGN1((*colorsP)[0], 0);
-         PNM_ASSIGN1((*colorsP)[1], *maxvalP);
+diff -urNp a/converter/other/xwdtopnm.c b/converter/other/xwdtopnm.c
+--- a/converter/other/xwdtopnm.c	2025-02-03 09:24:28.345500482 +0100
++++ b/converter/other/xwdtopnm.c	2025-02-03 09:55:18.695851996 +0100
+@@ -243,6 +243,10 @@ processX10Header(X10WDFileHeader *  cons
+         *colorsP = pnm_allocrow(*maxvalP + 1);
+         for (i = 0; i <= *maxvalP; ++i)
+             PNM_ASSIGN1((*colorsP)[i], i);
 +        overflow_add(h10P->pixmap_width, 15);
 +        if(h10P->pixmap_width < 0)
 +            pm_error("assert: negative width");
 +        overflow2((((h10P->pixmap_width + 15) / 16) * 16 - h10P->pixmap_width), 8);
          *padrightP =
              (((h10P->pixmap_width + 15) / 16) * 16 - h10P->pixmap_width) * 8;
-         *bits_per_itemP = 16;
-@@ -635,6 +639,7 @@ processX11Header(X11WDFileHeader *  cons
- 
-     *colsP = h11FixedP->pixmap_width;
-     *rowsP = h11FixedP->pixmap_height;
+         *bitsPerItemP = 16;
+@@ -671,6 +675,7 @@ processX11Header(const X11WDFileHeader *
+                  "%u bits per pixel, which is too many for this program "
+                  "to compute",
+                  h11FixedP->pixmap_width, h11FixedP->bits_per_pixel);
 +    overflow2(h11FixedP->bytes_per_line, 8);
      *padrightP =
          h11FixedP->bytes_per_line * 8 -
          h11FixedP->pixmap_width * h11FixedP->bits_per_pixel;
-diff -ruNp a/converter/pbm/mdatopbm.c b/converter/pbm/mdatopbm.c
---- a/converter/pbm/mdatopbm.c	2021-06-02 15:53:59.826205573 +0200
-+++ b/converter/pbm/mdatopbm.c	2021-06-02 20:23:21.807634239 +0200
-@@ -245,10 +245,13 @@ main(int argc, char **argv) {
-         pm_readlittleshort(infile, &yy); nInCols = yy;
+diff -urNp a/converter/pbm/mdatopbm.c b/converter/pbm/mdatopbm.c
+--- a/converter/pbm/mdatopbm.c	2025-02-03 09:24:28.358500411 +0100
++++ b/converter/pbm/mdatopbm.c	2025-02-03 09:57:03.495422912 +0100
+@@ -283,11 +283,13 @@ main(int argc, const char **argv) {
+         pm_readlittleshort(ifP, &yy); nInCols = yy;
      }
-     
+ 
 +    overflow2(nOutCols, 8);
      nOutCols = 8 * nInCols;
      nOutRows = nInRows;
--    if (bScale) 
+-    if (bScale)
 +    if (bScale) {
 +        overflow2(nOutRows, 2);
          nOutRows *= 2;
+-
 +    }
- 
      data = pbm_allocarray(nOutCols, nOutRows);
-     
-diff -ruNp a/converter/pbm/mgrtopbm.c b/converter/pbm/mgrtopbm.c
---- a/converter/pbm/mgrtopbm.c	2022-01-03 16:41:24.856969944 +0100
-+++ b/converter/pbm/mgrtopbm.c	2022-01-03 16:43:27.023842152 +0100
+ 
+     MALLOCARRAY_NOFAIL(mdrow, nInCols);
+diff -urNp a/converter/pbm/mgrtopbm.c b/converter/pbm/mgrtopbm.c
+--- a/converter/pbm/mgrtopbm.c	2025-02-03 09:24:28.358500411 +0100
++++ b/converter/pbm/mgrtopbm.c	2025-02-03 09:58:19.232265999 +0100
 @@ -105,6 +105,8 @@ readMgrHeader(FILE *          const ifP,
      interpHdrWidth (head, colsP);
      interpHdrHeight(head, rowsP);
@@ -227,31 +185,9 @@ diff -ruNp a/converter/pbm/mgrtopbm.c b/converter/pbm/mgrtopbm.c
      *padrightP = ((*colsP + pad - 1) / pad) * pad - *colsP;
  }
  
-diff --git a/converter/pbm/pbmto4425.c b/converter/pbm/pbmto4425.c
-index 1d97ac6..c4c8cbb 100644
---- a/converter/pbm/pbmto4425.c
-+++ b/converter/pbm/pbmto4425.c
-@@ -2,6 +2,7 @@
- 
- #include "nstring.h"
- #include "pbm.h"
-+#include <string.h>
- 
- static char bit_table[2][3] = {
- {1, 4, 0x10},
-@@ -160,7 +161,7 @@ main(int argc, char * argv[]) {
-     xres = vmap_width * 2;
-     yres = vmap_height * 3;
- 
--    vmap = malloc(vmap_width * vmap_height * sizeof(char));
-+    vmap = malloc3(vmap_width, vmap_height, sizeof(char));
-     if(vmap == NULL)
- 	{
-         pm_error( "Cannot allocate memory" );
-diff --git a/converter/pbm/pbmtogem.c b/converter/pbm/pbmtogem.c
-index 4fd30e9..c82757d 100644
---- a/converter/pbm/pbmtogem.c
-+++ b/converter/pbm/pbmtogem.c
+diff -urNp a/converter/pbm/pbmtogem.c b/converter/pbm/pbmtogem.c
+--- a/converter/pbm/pbmtogem.c	2025-02-03 09:24:28.358500411 +0100
++++ b/converter/pbm/pbmtogem.c	2025-02-03 10:25:34.259707343 +0100
 @@ -79,6 +79,7 @@ putinit (int const rows, int const cols)
    bitsperitem = 0;
    bitshift = 7;
@@ -260,9 +196,9 @@ index 4fd30e9..c82757d 100644
    outmax = (cols + 7) / 8;
    outrow = (unsigned char *) pm_allocrow (outmax, sizeof (unsigned char));
    lastrow = (unsigned char *) pm_allocrow (outmax, sizeof (unsigned char));
-diff -ruNp a/converter/pbm/pbmtogo.c b/converter/pbm/pbmtogo.c
---- a/converter/pbm/pbmtogo.c	2021-06-02 15:53:59.826205573 +0200
-+++ b/converter/pbm/pbmtogo.c	2021-06-02 20:23:21.809634256 +0200
+diff -urNp a/converter/pbm/pbmtogo.c b/converter/pbm/pbmtogo.c
+--- a/converter/pbm/pbmtogo.c	2025-02-03 09:24:28.359500407 +0100
++++ b/converter/pbm/pbmtogo.c	2025-02-03 10:26:22.723447123 +0100
 @@ -158,6 +158,7 @@ main(int           argc,
      bitrow = pbm_allocrow(cols);
  
@@ -271,14 +207,14 @@ diff -ruNp a/converter/pbm/pbmtogo.c b/converter/pbm/pbmtogo.c
      rucols = ( cols + 7 ) / 8;
      bytesperrow = rucols;       /* GraphOn uses bytes */
      rucols = rucols * 8;
-diff -ruNp a/converter/pbm/pbmtolj.c b/converter/pbm/pbmtolj.c
---- a/converter/pbm/pbmtolj.c	2021-06-02 15:53:59.828205592 +0200
-+++ b/converter/pbm/pbmtolj.c	2021-06-02 20:23:21.810634265 +0200
-@@ -120,7 +120,11 @@ parseCommandLine(int argc, char ** argv,
+diff -urNp a/converter/pbm/pbmtolj.c b/converter/pbm/pbmtolj.c
+--- a/converter/pbm/pbmtolj.c	2025-02-03 09:24:28.357500417 +0100
++++ b/converter/pbm/pbmtolj.c	2025-02-03 10:29:37.442401385 +0100
+@@ -120,7 +120,11 @@ parseCommandLine(int argc, const char **
  static void
  allocateBuffers(unsigned int const cols) {
  
-+    overflow_add(cols, 8);
++    overflow_add(cols, 7);
      rowBufferSize = (cols + 7) / 8;
 +    overflow_add(rowBufferSize, 128);
 +    overflow_add(rowBufferSize, rowBufferSize+128);
@@ -286,420 +222,162 @@ diff -ruNp a/converter/pbm/pbmtolj.c b/converter/pbm/pbmtolj.c
      packBufferSize = rowBufferSize + (rowBufferSize + 127) / 128 + 1;
      deltaBufferSize = rowBufferSize + rowBufferSize / 8 + 10;
  
-diff -ruNp a/converter/pbm/pbmtomda.c b/converter/pbm/pbmtomda.c
---- a/converter/pbm/pbmtomda.c	2021-06-02 15:53:59.827205582 +0200
-+++ b/converter/pbm/pbmtomda.c	2021-06-02 20:23:21.810634265 +0200
-@@ -179,6 +179,7 @@ int main(int argc, char **argv)
-     
-     nOutRowsUnrounded = bScale ? nInRows/2 : nInRows;
+diff -urNp a/converter/pbm/pbmtomda.c b/converter/pbm/pbmtomda.c
+--- a/converter/pbm/pbmtomda.c	2025-02-03 09:24:28.357500417 +0100
++++ b/converter/pbm/pbmtomda.c	2025-02-03 10:31:40.714199457 +0100
+@@ -204,6 +204,7 @@ main(int argc, const char ** argv) {
+ 
+     nOutRowsUnrounded = cmdline.dscale ? nInRows/2 : nInRows;
  
 +    overflow_add(nOutRowsUnrounded, 3);
      nOutRows = ((nOutRowsUnrounded + 3) / 4) * 4;
-         /* MDA wants rows a multiple of 4 */   
+         /* MDA wants rows a multiple of 4 */
      nOutCols = nInCols / 8;
-diff -ruNp a/converter/pbm/pbmtoppa/pbm.c b/converter/pbm/pbmtoppa/pbm.c
---- a/converter/pbm/pbmtoppa/pbm.c	2021-06-02 15:53:59.830205611 +0200
-+++ b/converter/pbm/pbmtoppa/pbm.c	2021-06-02 20:23:21.811634274 +0200
-@@ -11,185 +11,128 @@
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
--#include <limits.h>
+diff -urNp a/converter/pbm/pbmtoppa/pbm.c b/converter/pbm/pbmtoppa/pbm.c
+--- a/converter/pbm/pbmtoppa/pbm.c	2025-02-03 09:24:28.356500423 +0100
++++ b/converter/pbm/pbmtoppa/pbm.c	2025-02-03 10:48:49.928347495 +0100
+@@ -157,6 +157,7 @@ pbm_readline(pbm_stat *      const pbmSt
+                 break;
+             case P4: {
+                 int tmp, tmp2;
++                overflow_add(pbmStatP->width, 7);
+                 tmp = (pbmStatP->width+7)/8;
+                 tmp2 = fread(data,1,tmp,pbmStatP->fptr);
+                 if (tmp2 == tmp) {
+@@ -189,6 +190,7 @@ pbm_unreadline(pbm_stat * const pbmStatP
  
--#include "pm.h"
--#include "nstring.h"
- #include "ppapbm.h"
- 
--int
--make_pbm_stat(pbm_stat * const pbmStatP,
--              FILE *     const ifP) {
--
--    char line[1024];
--    char * rc;
--    int retval;
--
--    pbmStatP->fptr         = ifP;
--    pbmStatP->version      = none;
--    pbmStatP->current_line = 0;
--    pbmStatP->unread       = 0;
--
--    rc = fgets(line, 1024, ifP);
--    if (rc == NULL)
--        retval = 0;
--    else {
--        line[strlen(line)-1] = 0;
--
--        if (streq(line,"P1"))
--            pbmStatP->version=P1;
--        if (streq(line,"P4"))
--            pbmStatP->version=P4;
--
--        if (pbmStatP->version == none) {
--            pm_message("unknown PBM magic '%s'", line);
--            retval = 0;
--        } else {
--            do {
--                char * rc;
--                rc = fgets(line, 1024, ifP);
--                if (rc == NULL)
--                    return 0;
--            } while (line[0] == '#');
--            {
--                int rc;
--                rc = sscanf(line, "%d %d",
--                            &pbmStatP->width, &pbmStatP->height);
--                if (rc != 2)
--                    retval = 0;
--                else {
--                    if (pbmStatP->width < 0) {
--                        pm_message("Image has negative width");
--                        retval = 0;
--                    } else if (pbmStatP->width > INT_MAX/2) {
--                        pm_message("Uncomputeably large width: %d",
--                                   pbmStatP->width);
--                        retval = 0;
--                    } else if (pbmStatP->height < 0) {
--                        pm_message("Image has negative height");
--                        retval = 0;
--                    } else if (pbmStatP->height > INT_MAX/2) {
--                        pm_message("Uncomputeably large height: %d",
--                                   pbmStatP->height);
--                        retval = 0;
--                    } else
--                        retval = 1;
--                }
--            }
--        }
--    }
--    return retval;
--}
-+int make_pbm_stat(pbm_stat* pbm,FILE* fptr)
-+{
-+  char line[1024];
- 
-+  pbm->fptr=fptr;
-+  pbm->version=none;
-+  pbm->current_line=0;
-+  pbm->unread = 0;
- 
-+  if (fgets (line, 1024, fptr) == NULL)
-+    return 0;
-+  line[strlen(line)-1] = 0;
- 
--static int
--getbytes(FILE *          const ifP,
--         unsigned int    const width,
--         unsigned char * const data) {
--
--    unsigned char mask;
--    unsigned char acc;
--    unsigned char * place;
--    unsigned int num;
--    int retval;
--
--    if (width == 0)
--        retval = 0;
--    else {
--        for (mask = 0x80, acc = 0, num = 0, place = data; num < width; ) {
--            switch (getc(ifP)) {
--            case EOF:
--                return 0;
--            case '1':
--                acc |= mask;
--                /* fall through */
--            case '0':
--                mask >>= 1;
--                ++num;
--                if (mask == 0x00) { /* if (num % 8 == 0) */
--                    *place++ = acc;
--                    acc = 0;
--                    mask = 0x80;
--                }
--            }
--        }
--        if (width % 8 != 0)
--            *place = acc;
--
--        retval = 1;
--    }
--    return retval;
--}
-+  if(!strcmp(line,"P1")) pbm->version=P1;
-+  if(!strcmp(line,"P4")) pbm->version=P4;
-+  if(pbm->version == none)
-+  {
-+    fprintf(stderr,"pbm_readheader(): unknown PBM magic '%s'\n",line);
-+    return 0;
-+  }
- 
-+  do
-+    if (fgets (line, 1024, fptr) == NULL)
-+      return 0;
-+  while (line[0] == '#');
- 
-+  if (2 != sscanf (line, "%d %d", &pbm->width, &pbm->height))
-+    return 0;
- 
--int
--pbm_readline(pbm_stat *      const pbmStatP,
--             unsigned char * const data) {
--/*----------------------------------------------------------------------------
--  Read a single line into data which must be at least (pbmStatP->width+7)/8
--  bytes of storage.
-------------------------------------------------------------------------------*/
--    int retval;
--
--    if (pbmStatP->current_line >= pbmStatP->height)
--        retval = 0;
--    else {
--        if (pbmStatP->unread) {
--            memcpy(data, pbmStatP->revdata, (pbmStatP->width+7)/8);
--            ++pbmStatP->current_line;
--            pbmStatP->unread = 0;
--            free(pbmStatP->revdata);
--            pbmStatP->revdata = NULL;
--            retval = 1;
--        } else {
--            switch (pbmStatP->version) {
--            case P1:
--                if (getbytes(pbmStatP->fptr, pbmStatP->width, data)) {
--                    pbmStatP->current_line++;
--                    retval = 1;
--                } else
--                    retval = 0;
--                break;
--            case P4: {
--                int tmp, tmp2;
--                tmp = (pbmStatP->width+7)/8;
--                tmp2 = fread(data,1,tmp,pbmStatP->fptr);
--                if (tmp2 == tmp) {
--                    ++pbmStatP->current_line;
--                    retval = 1;
--                } else {
--                    pm_message("error reading line data (%d)", tmp2);
--                    retval = 0;
--                }
--            } break;
--
--            default:
--                pm_message("unknown PBM version");
--                retval = 0;
--            }
--        }
--    }
--    return retval;
-+  return 1;
- }
- 
-+static int getbytes(FILE *fptr,int width,unsigned char* data)
-+{
-+  unsigned char mask,acc,*place;
-+  int num;
-+
-+  if(!width) return 0;
-+  for(mask=0x80, acc=0, num=0, place=data; num<width; )
-+  {
-+    switch(getc(fptr))
-+    {
-+    case EOF:      
-+      return 0;
-+    case '1':
-+      acc|=mask;
-+      /* fall through */
-+    case '0':
-+      mask>>=1;
-+      num++;
-+      if(!mask) /* if(num%8 == 0) */
-+      {
-+	*place++ = acc;
-+	acc=0;
-+	mask=0x80;
-+      }
-+    }
-+  }
-+  if(width%8)
-+    *place=acc;
-+  return 1;
-+}
- 
-+/* Reads a single line into data which must be at least (pbm->width+7)/8
-+   bytes of storage */
-+int pbm_readline(pbm_stat* pbm,unsigned char* data)
-+{
-+  int tmp,tmp2;
-+
-+  if(pbm->current_line >= pbm->height) return 0;
-+
-+  if (pbm->unread)
-+    {
-+      memcpy (data, pbm->revdata, (pbm->width+7)/8);
-+      pbm->current_line++;
-+      pbm->unread = 0;
-+      free (pbm->revdata);
-+      pbm->revdata = NULL;
-+      return 1;
-+    }
- 
--void
--pbm_unreadline(pbm_stat * const pbmStatP,
--               void *     const data) {
--/*----------------------------------------------------------------------------
--  Push a line back into the buffer; we read too much!
-------------------------------------------------------------------------------*/
--    /* can store only one line in the unread buffer */
--
--    if (!pbmStatP->unread) {
--        pbmStatP->unread = 1;
--        pbmStatP->revdata = malloc ((pbmStatP->width+7)/8);
--        memcpy(pbmStatP->revdata, data, (pbmStatP->width+7)/8);
--        --pbmStatP->current_line;
-+  switch(pbm->version)
-+  {
-+  case P1:
-+    if(getbytes(pbm->fptr,pbm->width,data))
-+    {
-+      pbm->current_line++;
-+      return 1;
-     }
--}
-+    return 0;
-+
-+  case P4:
-+    overflow_add(pbm->width, 7);
-+    tmp=(pbm->width+7)/8;
-+    tmp2=fread(data,1,tmp,pbm->fptr);
-+    if(tmp2 == tmp)
-+    {
-+      pbm->current_line++;
-+      return 1;
-+    }
-+    fprintf(stderr,"pbm_readline(): error reading line data (%d)\n",tmp2);
-+    return 0;
- 
-+  default:
-+    fprintf(stderr,"pbm_readline(): unknown PBM version\n");
-+    return 0;
-+  }
-+}
- 
-+/* push a line back into the buffer; we read too much! */
-+void pbm_unreadline (pbm_stat *pbm, void *data)
-+{
-+  /* can only store one line in the unread buffer */
-+  if (pbm->unread)
-+    return;
-+
-+  pbm->unread = 1;
-+  overflow_add(pbm->width, 7);
-+  pbm->revdata = malloc ((pbm->width+7)/8);
-+  memcpy (pbm->revdata, data, (pbm->width+7)/8);
-+  pbm->current_line--;
-+}
-diff -ruNp a/converter/pbm/pbmtoppa/pbmtoppa.c b/converter/pbm/pbmtoppa/pbmtoppa.c
---- a/converter/pbm/pbmtoppa/pbmtoppa.c	2021-06-02 15:53:59.829205601 +0200
-+++ b/converter/pbm/pbmtoppa/pbmtoppa.c	2021-06-02 20:23:21.811634274 +0200
-@@ -453,6 +453,7 @@ main(int argc, char *argv[]) {
+     if (!pbmStatP->unread) {
+         pbmStatP->unread = 1;
++        overflow_add(pbmStatP->width, 7);
+         pbmStatP->revdata = malloc ((pbmStatP->width+7)/8);
+         memcpy(pbmStatP->revdata, data, (pbmStatP->width+7)/8);
+         --pbmStatP->current_line;
+diff -urNp a/converter/pbm/pbmtoppa/pbmtoppa.c b/converter/pbm/pbmtoppa/pbmtoppa.c
+--- a/converter/pbm/pbmtoppa/pbmtoppa.c	2025-02-03 09:24:28.356500423 +0100
++++ b/converter/pbm/pbmtoppa/pbmtoppa.c	2025-02-03 10:49:30.440158354 +0100
+@@ -456,6 +456,7 @@ main(int argc, char *argv[]) {
              pm_error("main(): unrecognized parameter '%s'", argv[argn]);
      }
  
 +    overflow_add(Width, 7);
-     Pwidth=(Width+7)/8;
-     printer.fptr=out;
+     Pwidth = (Width+7)/8;
+     printer.fptr = ofP;
  
-diff -ruNp a/converter/pbm/pbmtoxbm.c b/converter/pbm/pbmtoxbm.c
---- a/converter/pbm/pbmtoxbm.c	2021-06-02 15:53:59.829205601 +0200
-+++ b/converter/pbm/pbmtoxbm.c	2021-06-02 20:23:21.812634282 +0200
-@@ -352,6 +352,8 @@ convertRaster(FILE *          const ifP,
- 
-     unsigned char * bitrow;
-     unsigned int row;
-+    
-+    overflow_add(cols, padright);
+diff -urNp a/converter/pbm/pbmtoxbm.c b/converter/pbm/pbmtoxbm.c
+--- a/converter/pbm/pbmtoxbm.c	2025-02-03 09:24:28.357500417 +0100
++++ b/converter/pbm/pbmtoxbm.c	2025-02-03 10:50:31.351873866 +0100
+@@ -370,6 +370,7 @@ convertRaster(FILE *          const ifP,
  
      putinit(xbmVersion);
  
-diff --git a/converter/pbm/pktopbm.c b/converter/pbm/pktopbm.c
-index 712f339..b6fcb02 100644
---- a/converter/pbm/pktopbm.c
-+++ b/converter/pbm/pktopbm.c
-@@ -280,6 +280,7 @@ main(int argc, char *argv[]) {
-         if (flagbyte == 7) {            /* long form preamble */
-             integer packetlength = get32() ;    /* character packet length */
-             car = get32() ;         /* character number */
-+            overflow_add(packetlength, pktopbm_pkloc);
-             endofpacket = packetlength + pktopbm_pkloc;
-                 /* calculate end of packet */
-             if ((car >= MAXPKCHAR) || !filename[car]) {
-diff -ruNp a/converter/pbm/thinkjettopbm.l b/converter/pbm/thinkjettopbm.l
---- a/converter/pbm/thinkjettopbm.l	2021-06-02 15:53:59.828205592 +0200
-+++ b/converter/pbm/thinkjettopbm.l	2021-06-02 20:23:21.813634291 +0200
-@@ -114,7 +114,9 @@ DIG             [0-9]
- <RASTERMODE>\033\*b{DIG}+W  {
-                             int l;
++    overflow_add(cols, padright);
+     bitrow = pbm_allocrow_packed(cols + padright);
+ 
+     for (row = 0; row < rows; ++row) {
+diff -urNp a/converter/pbm/pktopbm.c b/converter/pbm/pktopbm.c
+--- a/converter/pbm/pktopbm.c	2025-02-03 09:24:28.357500417 +0100
++++ b/converter/pbm/pktopbm.c	2025-02-03 17:09:21.430572232 +0100
+@@ -454,6 +454,7 @@ readCharacterHeader(int *          const
+     if (packetLength > UINT_MAX - pkLoc)
+         pm_error("Invalid character header - excessive packet length");
+ 
++    overflow_add(packetLength, pkLoc);
+     *endOfPacketP = packetLength + pkLoc;
+ 
+     *cheightP = cheight;
+diff -urNp a/converter/pbm/thinkjettopbm.l b/converter/pbm/thinkjettopbm.l
+--- a/converter/pbm/thinkjettopbm.l	2025-02-03 09:24:28.359500407 +0100
++++ b/converter/pbm/thinkjettopbm.l	2025-02-03 17:11:07.302725005 +0100
+@@ -117,6 +117,7 @@ DIG             [0-9]
                              if (rowCount >= rowCapacity) {
--                                rowCapacity += 100;
-+				overflow_add(rowCapacity, 100);
-+                                 rowCapacity += 100;
-+				overflow2(rowCapacity, sizeof *rows);
-                                 rows = realloc (rows, rowCapacity * sizeof *rows);
+                                 if (rowCapacity > INT_MAX-100)
+                                     pm_error("Too many rows to count");
++                                overflow_add(rowCapacity, 100);
+                                 rowCapacity += 100;
+                                 REALLOCARRAY(rows, rowCapacity);
                                  if (rows == NULL)
-                                     pm_error ("Out of memory.");
-@@ -226,6 +228,8 @@ yywrap (void)
+@@ -232,6 +233,7 @@ yywrap (void)
      /*
       * Quite simple since ThinkJet bit arrangement matches PBM
       */
-+
 +    overflow2(maxRowLength, 8);
      pbm_writepbminit(stdout, maxRowLength*8, rowCount, 0);
  
      packed_bitrow = malloc(maxRowLength);
-diff -ruNp a/converter/pbm/ybmtopbm.c b/converter/pbm/ybmtopbm.c
---- a/converter/pbm/ybmtopbm.c	2022-01-03 16:41:24.857969951 +0100
-+++ b/converter/pbm/ybmtopbm.c	2022-01-03 16:42:59.671646876 +0100
-@@ -49,6 +49,8 @@ getinit(FILE *         const ifP,
-     *colsP = (unsigned int) cols;
-     *rowsP = (unsigned int) rows;
-     *depthP = 1;
+diff -urNp a/converter/pbm/ybmtopbm.c b/converter/pbm/ybmtopbm.c
+--- a/converter/pbm/ybmtopbm.c	2025-02-03 09:24:28.359500407 +0100
++++ b/converter/pbm/ybmtopbm.c	2025-02-03 17:17:57.638369880 +0100
+@@ -88,8 +88,12 @@ main(int argc, const char * argv[]) {
+ 
+     pbm_writepbminit(stdout, cols, rows, 0);
+ 
++    overflow_add(cols, 8);
 +
-+    overflow_add(*colsP, 15);
- }
+     bitrow = pbm_allocrow_packed(cols + 8);
  
- 
-diff -ruNp a/converter/pgm/lispmtopgm.c b/converter/pgm/lispmtopgm.c
---- a/converter/pgm/lispmtopgm.c	2021-06-02 15:53:59.831205621 +0200
-+++ b/converter/pgm/lispmtopgm.c	2021-06-02 20:23:21.814634300 +0200
-@@ -58,6 +58,7 @@ main( argc, argv )
-         pm_error( "depth (%d bits) is too large", depth);
- 
-     pgm_writepgminit( stdout, cols, rows, (gray) maxval, 0 );
-+    overflow_add(cols, 7);
-     grayrow = pgm_allocrow( ( cols + 7 ) / 8 * 8 );
- 
-     for ( row = 0; row < rows; ++row )
-@@ -102,6 +103,8 @@ getinit( file, colsP, rowsP, depthP, pad
-     
-     if ( *depthP == 0 )
- 	*depthP = 1;	/* very old file */
++    overflow_add(cols, 15);
 +
-+    overflow_add((int)colsP, 31);
-     
-     *padrightP = ( ( *colsP + 31 ) / 32 ) * 32 - *colsP;
-     
-diff -ruNp a/converter/pgm/psidtopgm.c b/converter/pgm/psidtopgm.c
---- a/converter/pgm/psidtopgm.c	2021-06-02 15:53:59.830205611 +0200
-+++ b/converter/pgm/psidtopgm.c	2021-06-02 20:23:21.815634309 +0200
-@@ -78,6 +78,7 @@ main(int     argc,
-         pm_error("bits/sample (%d) is too large.", bitspersample);
- 
-     pgm_writepgminit(stdout, cols, rows, maxval, 0);
-+    overflow_add(cols, 7);
-     grayrow = pgm_allocrow((cols + 7) / 8 * 8);
      for (row = 0; row < rows; ++row) {
-         unsigned int col;
-diff --git a/converter/ppm/Makefile b/converter/ppm/Makefile
-index 003ef8d..b97349d 100644
---- a/converter/ppm/Makefile
-+++ b/converter/ppm/Makefile
+         uint16_t *   const itemrow = (uint16_t *) bitrow;
+         unsigned int const itemCt  = (cols + 15) / 16;
+diff -urNp a/converter/ppm/ilbmtoppm.c b/converter/ppm/ilbmtoppm.c
+--- a/converter/ppm/ilbmtoppm.c	2025-02-03 09:24:28.330500563 +0100
++++ b/converter/ppm/ilbmtoppm.c	2025-02-03 18:06:05.606638402 +0100
+@@ -1385,6 +1385,9 @@ dcol_to_ppm(FILE *         const ifP,
+     if (redmaxval != maxval || greenmaxval != maxval || bluemaxval != maxval)
+         pm_message("scaling colors to %u bits", pm_maxvaltobits(maxval));
+ 
++    overflow_add(redmaxval, 1);
++    overflow_add(greenmaxval, 1);
++    overflow_add(bluemaxval, 1);
+     MALLOCARRAY_NOFAIL(redtable,   redmaxval   + 1);
+     MALLOCARRAY_NOFAIL(greentable, greenmaxval + 1);
+     MALLOCARRAY_NOFAIL(bluetable,  bluemaxval  + 1);
+@@ -1875,12 +1878,14 @@ PCHG_ConvertSmall(PCHGHeader *    const
+             else {
+                 unsigned int const changeCt16 = *dataCursor++;
+                 unsigned int const changeCt32 = *dataCursor++;
++                overflow_add(changeCt16, changeCt32);
+                 unsigned int const changeCt = changeCt16 + changeCt32;
+ 
+                 unsigned int i;
+ 
+                 remDataSize -= 2;
+ 
++                overflow_add(changeCt, 1);
+                 MALLOCARRAY_NOFAIL(cmapP->mp_change[row], changeCt + 1);
+                 for (i = 0; i < changeCt; ++i) {
+                     if (totalChangeCt >= pchgP->TotalChanges) goto fail;
+@@ -2122,6 +2127,7 @@ read_pchg(FILE *     const ifP,
+                          "is less than minreg (%u)",
+                          PCHG.MaxReg, PCHG.MinReg);
+             else {
++                overflow_add(PCHG.MaxReg-PCHG.MinReg, 2);
+                 unsigned int const nch = PCHG.MaxReg - PCHG.MinReg + 1;
+ 
+                 unsigned int i;
+diff -urNp a/converter/ppm/imgtoppm.c b/converter/ppm/imgtoppm.c
+--- a/converter/ppm/imgtoppm.c	2025-02-03 09:24:28.330500563 +0100
++++ b/converter/ppm/imgtoppm.c	2025-02-03 18:10:34.478961449 +0100
+@@ -85,6 +85,7 @@ main(int argc, const char ** argv) {
+             len = atoi((char*) buf);
+             if (fread(buf, len, 1, ifP) != 1)
+                 pm_error("bad colormap buf");
++            overflow2(cmaplen, 3);
+             if (len != cmaplen * 3) {
+                 pm_message(
+                     "cmaplen (%u) and colormap buf length (%u) do not match",
+@@ -105,6 +106,7 @@ main(int argc, const char ** argv) {
+                 pm_error("bad pixel data header");
+             buf[8] = '\0';
+             len = atoi((char*) buf);
++            overflow2(cols, rows);
+             if (len != cols * rows)
+                 pm_message(
+                     "pixel data length (%u) does not match image size (%u)",
+diff -urNp a/converter/ppm/Makefile b/converter/ppm/Makefile
+--- a/converter/ppm/Makefile	2025-02-03 09:24:28.331500558 +0100
++++ b/converter/ppm/Makefile	2025-02-03 17:39:13.338685028 +0100
 @@ -11,7 +11,7 @@ SUBDIRS = hpcdtoppm ppmtompeg
  
  PORTBINARIES =	411toppm eyuvtoppm gouldtoppm ilbmtoppm imgtoppm \
@@ -709,528 +387,84 @@ index 003ef8d..b97349d 100644
  		ppmtoacad ppmtoapplevol ppmtoarbtxt ppmtoascii \
  		ppmtobmp ppmtoeyuv ppmtogif ppmtoicr ppmtoilbm \
  		ppmtoleaf ppmtolj ppmtomitsu ppmtoneo \
-diff --git a/converter/ppm/ilbmtoppm.c b/converter/ppm/ilbmtoppm.c
-index b9b8986..f4fe331 100644
---- a/converter/ppm/ilbmtoppm.c
-+++ b/converter/ppm/ilbmtoppm.c
-@@ -608,6 +608,7 @@ decode_row(FILE *          const ifP,
-     rawtype *chp;
+diff -urNp a/converter/ppm/pcxtoppm.c b/converter/ppm/pcxtoppm.c
+--- a/converter/ppm/pcxtoppm.c	2025-02-03 09:24:28.329500569 +0100
++++ b/converter/ppm/pcxtoppm.c	2025-02-03 18:12:34.245400166 +0100
+@@ -378,6 +378,7 @@ pcxPlanesToPixels(unsigned char * const
+    to conceive how this subroutine should work with other numbers of bits per
+    sample, but it doesn't.
+ -----------------------------------------------------------------------------*/
++    overflow2(bytesPerLine, 8);
+     unsigned int const pixelCt = bytesPerLine * 8;
  
-     cols = bmhdP->w;
-+    overflow_add(cols, 15);
-     bytes = RowBytes(cols);
-     for( plane = 0; plane < nPlanes; plane++ ) {
-         int mask;
-@@ -695,6 +696,23 @@ decode_mask(FILE *          const ifP,
-  Multipalette handling
-  ****************************************************************************/
- 
-+static void *
-+xmalloc2(x, y)
-+    int x;
-+    int y;
-+{
-+    void *mem;
-+
-+    overflow2(x,y);
-+    if( x * y == 0 )
-+        return NULL;
-+
-+    mem = malloc2(x,y);
-+    if( mem == NULL )
-+        pm_error("out of memory allocating %d bytes", x * y);
-+    return mem;
-+}
-+
- 
- static void
- multi_adjust(ColorMap *            const cmapP,
-@@ -1363,6 +1381,9 @@ dcol_to_ppm(FILE *         const ifP,
-     if( redmaxval != maxval || greenmaxval != maxval || bluemaxval != maxval )
-         pm_message("scaling colors to %d bits", pm_maxvaltobits(maxval));
- 
-+    overflow_add(redmaxval, 1);
-+    overflow_add(greenmaxval, 1);
-+    overflow_add(bluemaxval, 1);
-     MALLOCARRAY_NOFAIL(redtable,   redmaxval   +1);
-     MALLOCARRAY_NOFAIL(greentable, greenmaxval +1);
-     MALLOCARRAY_NOFAIL(bluetable,  bluemaxval  +1);
-@@ -1802,7 +1823,9 @@ PCHG_ConvertSmall(PCHGHeader *    const
-             ChangeCount32 = *data++;
-             remDataSize -= 2;
- 
-+            overflow_add(ChangeCount16, ChangeCount32);
-             changes = ChangeCount16 + ChangeCount32;
-+            overflow_add(changes, 1);
-             for (i = 0; i < changes; ++i) {
-                 if (totalchanges >= pchgP->TotalChanges) goto fail;
-                 if (remDataSize < 2) goto fail;
-@@ -2067,6 +2090,9 @@ read_pchg(FILE *     const ifP,
-             cmap->mp_change[i] = NULL;
-         if( PCHG.StartLine < 0 ) {
-             int nch;
-+            if(PCHG.MaxReg < PCHG.MinReg)
-+                pm_error("assert: MinReg > MaxReg");
-+            overflow_add(PCHG.MaxReg-PCHG.MinReg, 2);
-             nch = PCHG.MaxReg - PCHG.MinReg +1;
-             MALLOCARRAY_NOFAIL(cmap->mp_init, nch + 1);
-             for( i = 0; i < nch; i++ )
-@@ -2143,6 +2169,7 @@ process_body( FILE *          const ifP,
-     if (typeid == ID_ILBM) {
-         int isdeep;
- 
-+        overflow_add(bmhdP->w, 15);
-         MALLOCARRAY_NOFAIL(ilbmrow, RowBytes(bmhdP->w));
-         *viewportmodesP |= fakeviewport;      /* -isham/-isehb */
- 
-diff -ruNp a/converter/ppm/imgtoppm.c b/converter/ppm/imgtoppm.c
---- a/converter/ppm/imgtoppm.c	2021-06-02 15:53:59.845205755 +0200
-+++ b/converter/ppm/imgtoppm.c	2021-06-02 20:23:21.818634335 +0200
-@@ -84,6 +84,7 @@ main(int argc, char ** argv) {
-             len = atoi((char*) buf );
-             if ( fread( buf, len, 1, ifp ) != 1 )
-                 pm_error( "bad colormap buf" );
-+            overflow2(cmaplen, 3);
-             if ( cmaplen * 3 != len )
-             {
-                 pm_message(
-@@ -105,6 +106,7 @@ main(int argc, char ** argv) {
-                 pm_error( "bad pixel data header" );
-             buf[8] = '\0';
-             len = atoi((char*) buf );
-+            overflow2(cols, rows);
-             if ( len != cols * rows )
-                 pm_message(
-                     "pixel data length (%d) does not match image size (%d)",
-diff --git a/converter/ppm/pcxtoppm.c b/converter/ppm/pcxtoppm.c
-index e252ba2..270ae3b 100644
---- a/converter/ppm/pcxtoppm.c
-+++ b/converter/ppm/pcxtoppm.c
-@@ -409,6 +409,7 @@ pcx_planes_to_pixels(pixels, bitplanes, bytesperline, planes, bitsperpixel)
-     /*
-      * clear the pixel buffer
-      */
-+    overflow2(bytesperline, 8);
-     npixels = (bytesperline * 8) / bitsperpixel;
-     p    = pixels;
-     while (--npixels >= 0)
-@@ -470,6 +471,7 @@ pcx_16col_to_ppm(FILE *       const ifP,
+     unsigned int bitPlanesIdx;
+diff -urNp a/converter/ppm/pjtoppm.c b/converter/ppm/pjtoppm.c
+--- a/converter/ppm/pjtoppm.c	2025-02-03 09:24:28.329500569 +0100
++++ b/converter/ppm/pjtoppm.c	2025-02-03 18:21:28.636228030 +0100
+@@ -77,6 +77,7 @@ modifyImageMode1(unsigned int     const
+                              val = image[plane + row * planes][col+1];
+                          cmd >= 0 && i < newcols; --cmd, ++i)
+                         buf[i] = val;
++                        overflow_add(i, 1);
+                 }
+                 cols = MAX(cols, i);
+                 free(image[row * planes + plane]);
+@@ -90,6 +91,7 @@ modifyImageMode1(unsigned int     const
+             }
+         }
      }
- 
-     /*  BytesPerLine should be >= BitsPerPixel * cols / 8  */
-+    overflow2(BytesPerLine, 8);
-     rawcols = BytesPerLine * 8 / BitsPerPixel;
-     if (headerCols > rawcols) {
-         pm_message("warning - BytesPerLine = %d, "
-diff -ruNp a/converter/ppm/picttoppm.c b/converter/ppm/picttoppm.c
---- a/converter/ppm/picttoppm.c	2021-06-02 15:53:59.845205755 +0200
-+++ b/converter/ppm/picttoppm.c	2021-06-02 20:23:21.820634352 +0200
-@@ -1,3 +1,4 @@
-+#error "Unfixable. Don't ship me"
- /*
-  * picttoppm.c -- convert a MacIntosh PICT file to PPM format.
-  *
-diff -ruNp a/converter/ppm/pjtoppm.c b/converter/ppm/pjtoppm.c
---- a/converter/ppm/pjtoppm.c	2021-06-02 15:53:59.845205755 +0200
-+++ b/converter/ppm/pjtoppm.c	2021-06-02 20:23:21.821634361 +0200
-@@ -10,98 +10,66 @@
- ** implied warranty.
- */
- 
--#include <stdbool.h>
--
- #include "ppm.h"
--#include "pm_c_util.h"
- #include "mallocvar.h"
- 
- static char usage[] =  "[paintjetfile]";
- 
--
--
--static unsigned int
--uintProduct(unsigned int const multiplicand,
--            unsigned int const multiplier) {
--
--    if (UINT_MAX / multiplier < multiplicand)
--        pm_error("Airthmetic overflow");
--
--    return multiplicand * multiplier;
--}
--
--
--
-+static int egetc ARGS((FILE *fp));
- static int
--egetc(FILE * const ifP) {
-+egetc(fp)
-+    FILE *fp;
-+{
-     int c;
--
--    c = fgetc(ifP);
--
--    if (c == -1)
-+    if ((c = fgetc(fp)) == -1)
-         pm_error("unexpected end of file");
--
--    return c;
-+    return(c);
++    overflow2(cols, 8);
+     *colsP = cols * 8;  assert(cols < UINT_MAX/8);
  }
  
--
--
- int
--main(int argc, const char ** argv) {
--
-+main(argc, argv)
-+    int argc;
-+    char *argv[];
-+{
-     int cmd, val;
-     char buffer[BUFSIZ];
--    int planes = 3;
--    unsigned int rows;
--    unsigned int rowsX;
--    unsigned int cols;
--    bool colsIsSet;
-+    int planes = 3, rows = -1, cols = -1;
-+    int r = 0, c = 0, p = 0, i;
-     unsigned char **image = NULL;
-     int *imlen;
--    FILE * ifP;
-+    FILE *fp = stdin;
-     int mode;
--    bool modeIsSet;
-     int argn;
-     unsigned char bf[3];
--    pixel * pixrow;
--    int c;
--    int row;
--    int plane;
-+    pixel *pixrow;
- 
--    pm_proginit(&argc, argv);
- 
-+    ppm_init(&argc, argv);
-     argn = 1;
-     if (argn != argc)
--        ifP = pm_openr(argv[argn++]);
-+        fp = pm_openr(argv[argn++]);
-     else
--        ifP = stdin;
-+        fp = stdin;
- 
-     if (argn != argc)
-         pm_usage(usage);
- 
--    row = 0;  /* initial value */
--    plane = 0;  /* initial value */
--    modeIsSet = false;  /* initial value */
--    colsIsSet = false;  /* initial value */
--    rowsX = 0;  /* initial value */
--
--    while ((c = fgetc(ifP)) != -1) {
-+    while ((c = fgetc(fp)) != -1) {
-         if (c != '\033')
-             continue;
--        switch (c = egetc(ifP)) {
-+        switch (c = egetc(fp)) {
-         case 'E':   /* reset */
-             break;
--        case '*': {
--            unsigned int i;
--            cmd = egetc(ifP);
-+        case '*':
-+            cmd = egetc(fp);
-             for (i = 0; i < BUFSIZ; i++) {
--                if (!isdigit(c = egetc(ifP)) && c != '+' && c != '-')
-+                if (!isdigit(c = egetc(fp)) && c != '+' && c != '-')
-                     break;
-                 buffer[i] = c;
-             }
-             if (i != 0) {
-                 buffer[i] = '\0';
--                if (sscanf(buffer, "%d", &val) != 1)
-+                if (sscanf(buffer, "%d", &val) != 1) 
-                     pm_error("bad value `%s' at <ESC>*%c%c", buffer, cmd, c);
-             }
-             else
-@@ -125,18 +93,18 @@ main(int argc, const char ** argv) {
-             case 'r':
-                 switch (c) {
-                 case 'S':   /* width */
--                    if (val < 0)
-+                    if (val < 0) {
-                         pm_error("invalid width value");
--                    else {
-+                    } else {
-                         cols = val;
--                        colsIsSet = true;
-                     }
-                     break;
-                 case 'T':   /* height */
--                    if (val < 0)
-+                    if (val < 0) {
-                         pm_error ("invalid height value");
--                    else
--                        rowsX = val;
-+                    } else {
-+                        rows = val;
-+                    }
-                     break;
-                 case 'U':   /* planes */
-                     planes = val;
-@@ -163,40 +131,43 @@ main(int argc, const char ** argv) {
-                     if (val != 0 && val != 1)
-                         pm_error("unimplemented transmission mode %d", val);
-                     mode = val;
--                    modeIsSet = true;
-                     break;
+@@ -265,8 +267,10 @@ main(int argc, const char ** argv) {
                  case 'V':   /* send plane */
                  case 'W':   /* send last plane */
--                    if (row >= rowsX || image == NULL) {
+                     if (row >= rowsX || image == NULL) {
 -                        if (row >= rowsX)
--                            rowsX += 100;
-+                    if (rows == -1 || r >= rows || image == NULL) {
-+                        if (rows == -1 || r >= rows) {
++                        if (row >= rowsX) {
 +                            overflow_add(rows, 100);
-+                            rows += 100;
+                             rowsX += 100;
 +                        }
-+
-                         if (image == NULL) {
--                            MALLOCARRAY(image, uintProduct(rowsX, planes));
--                            MALLOCARRAY(imlen, uintProduct(rowsX, planes));
--                        } else {
--                            REALLOCARRAY(image, uintProduct(rowsX, planes));
--                            REALLOCARRAY(imlen, uintProduct(rowsX, planes));
-+                            image = (unsigned char **)
-+                                malloc3(rows , planes , sizeof(unsigned char *));
-+                            imlen = (int *) malloc3(rows , planes,  sizeof(int));
-                         }
-+                        else {
-+                            overflow2(rows,planes);
-+                            image = (unsigned char **)
-+                                realloc2(image, rows * planes,
-+                                    sizeof(unsigned char *));
-+                            imlen = (int *) realloc2(imlen, rows * planes, sizeof(int));                        }
+                         REALLOCARRAY(image, uintProduct(rowsX, planes));
+                         REALLOCARRAY(imlen, uintProduct(rowsX, planes));
                      }
-                     if (image == NULL || imlen == NULL)
-                         pm_error("out of memory");
--                    if (plane >= planes)
-+                    if (p == planes) 
-                         pm_error("too many planes");
--                    if (!colsIsSet)
--                        pm_error("missing width value");
--
--                    cols = MAX(cols, val);
--                    imlen[row * planes + plane] = val;
--                    MALLOCARRAY(image[row * planes + plane], val);
--                    if (image[row * planes + plane] == NULL)
-+                    cols = cols > val ? cols : val;
-+                    imlen[r * planes + p] = val;
-+                    MALLOCARRAY(image[r * planes + p], val);
-+                    if (image[r * planes + p] == NULL) 
-                         pm_error("out of memory");
--                    if (fread(image[row * planes + plane], 1, val, ifP) != val)
-+                    if (fread(image[r * planes + p], 1, val, fp) != val) 
-                         pm_error("short data");
-                     if (c == 'V')
--                        ++plane;
-+                        p++;
-                     else {
--                        plane = 0;
--                        ++row;
-+                        p = 0;
-+                        r++;
-                     }
-                     break;
-                 default:
-@@ -205,7 +176,7 @@ main(int argc, const char ** argv) {
-                 }
-                 break;
-             case 'p': /* Position */
--                if (plane != 0)
-+                if (p != 0) 
-                     pm_error("changed position in the middle of "
-                              "transferring planes");
-                 switch (c) {
-@@ -214,15 +185,15 @@ main(int argc, const char ** argv) {
-                     break;
-                 case 'Y':
-                     if (buffer[0] == '+')
--                        val = row + val;
-+                        val = r + val;
-                     if (buffer[0] == '-')
--                        val = row - val;
--                    for (; val > row; ++row)
--                        for (plane = 0; plane < 3; ++plane) {
--                            imlen[row * planes + plane] = 0;
--                            image[row * planes + plane] = NULL;
-+                        val = r - val;
-+                    for (; val > r; r++) 
-+                        for (p = 0; p < 3; p++) {
-+                            imlen[r * planes + p] = 0;
-+                            image[r * planes + p] = NULL;
-                         }
--                    row = val;
-+                    r = val;
-                     break;
-                 default:
-                     pm_message("uninmplemented <ESC>*%c%d%c", cmd, val, c);
-@@ -231,86 +202,65 @@ main(int argc, const char ** argv) {
-             default:
-                 pm_message("uninmplemented <ESC>*%c%d%c", cmd, val, c);
-                 break;
--             }
--        } /* case */
--        } /* switch */
-+            }
-+        }
-     }
--    pm_close(ifP);
--
--    if (!modeIsSet)
--        pm_error("Input does not contain a 'bM' transmission mode order");
--
--    rows = row;
-+    pm_close(fp);
-+    rows = r;
-     if (mode == 1) {
--        unsigned int const newcols = 10240;
--            /* It could not be larger than that! */
--
--        unsigned char * buf;
--        unsigned int row;
--
--        for (row = 0, cols = 0; row < rows; ++row) {
--            unsigned int plane;
--            if (image[row * planes] == NULL)
-+        unsigned char *buf;
-+        int newcols = 0;
-+        newcols = 10240; /* It could not be larger that that! */
-+        cols = 0;
-+        for (r = 0; r < rows; r++) {
-+            if (image[r * planes] == NULL)
-                 continue;
--            for (plane = 0; plane < planes; ++plane) {
--                unsigned int i;
--                unsigned int col;
-+            for (p = 0; p < planes; p++) {
-                 MALLOCARRAY(buf, newcols);
--                if (buf == NULL)
-+                if (buf == NULL) 
-                     pm_error("out of memory");
--                for (i = 0, col = 0;
--                     col < imlen[plane + row * planes];
--                     col += 2)
--                    for (cmd = image[plane + row * planes][col],
--                             val = image[plane + row * planes][col+1];
--                         cmd >= 0 && i < newcols; cmd--, i++)
-+                for (i = 0, c = 0; c < imlen[p + r * planes]; c += 2)
-+                    for (cmd = image[p + r * planes][c],
-+                             val = image[p + r * planes][c+1]; 
-+                         cmd >= 0 && i < newcols; cmd--, i++) {
-                         buf[i] = val;
--                cols = MAX(cols, i);
--                free(image[plane + row * planes]);
--                /*
--                 * This is less than what we have so it realloc should
-+                        overflow_add(i, 1);
-+                    }
-+                cols = cols > i ? cols : i;
-+                free(image[p + r * planes]);
-+                /* 
-+                 * This is less than what we have so it realloc should 
-                  * not return null. Even if it does, tough! We will
-                  * lose a line, and probably die on the next line anyway
-                  */
--                image[plane + row * planes] = realloc(buf, i);
-+                image[p + r * planes] = (unsigned char *) realloc(buf, i);
-             }
-         }
-+        overflow2(cols, 8);
-         cols *= 8;
-     }
--
-+            
-+       
-     ppm_writeppminit(stdout, cols, rows, (pixval) 255, 0);
-     pixrow = ppm_allocrow(cols);
--
--    for (row = 0; row < rows; ++row) {
--        if (image[row * planes] == NULL) {
--            unsigned int col;
--            for (col = 0; col < cols; ++col)
--                PPM_ASSIGN(pixrow[col], 0, 0, 0);
-+    for (r = 0; r < rows; r++) {
-+        if (image[r * planes] == NULL) {
-+            for (c = 0; c < cols; c++)
-+                PPM_ASSIGN(pixrow[c], 0, 0, 0);
-             continue;
-         }
--        {
--            unsigned int col;
--            unsigned int cmd;
--            for (cmd = 0, col = 0; col < cols; col += 8, ++cmd) {
--                unsigned int i;
--                for (i = 0; i < 8 && col + i < cols; ++i) {
--                    unsigned int plane;
--                    for (plane = 0; plane < planes; ++plane)
--                        if (mode == 0 && cmd >= imlen[row * planes + plane])
--                            bf[plane] = 0;
--                        else
--                            bf[plane] = (image[row * planes + plane][cmd] &
--                                     (1 << (7 - i))) ? 255 : 0;
--                    PPM_ASSIGN(pixrow[col + i], bf[0], bf[1], bf[2]);
--                }
-+        for (cmd = 0, c = 0; c < cols; c += 8, cmd++) 
-+            for (i = 0; i < 8 && c + i < cols; i++) {
-+                for (p = 0; p < planes; p++) 
-+                    if (mode == 0 && cmd >= imlen[r * planes + p])
-+                        bf[p] = 0;
-+                    else
-+                        bf[p] = (image[r * planes + p][cmd] & 
-+                                 (1 << (7 - i))) ? 255 : 0;
-+                PPM_ASSIGN(pixrow[c + i], bf[0], bf[1], bf[2]);
-             }
--        }
--        ppm_writeppmrow(stdout, pixrow, cols, 255, 0);
-+        ppm_writeppmrow(stdout, pixrow, cols, (pixval) 255, 0);
-     }
-     pm_close(stdout);
--
--    return 0;
-+    exit(0);
- }
--
--
--
-diff -ruNp a/converter/ppm/ppmtoeyuv.c b/converter/ppm/ppmtoeyuv.c
---- a/converter/ppm/ppmtoeyuv.c	2021-06-02 15:53:59.845205755 +0200
-+++ b/converter/ppm/ppmtoeyuv.c	2021-06-02 20:23:21.821634361 +0200
-@@ -114,6 +114,7 @@ create_multiplication_tables(const pixva
+@@ -277,6 +281,8 @@ main(int argc, const char ** argv) {
+                     if (!colsIsSet)
+                         pm_error("missing width value");
  
-     int index;
++                    overflow2(rows,planes);
++                    overflow_add(rows * planes, plane);
+                     cols = MAX(cols, val);
+                     imlen[row * planes + plane] = val;
+                     MALLOCARRAY(image[row * planes + plane], val);
+diff -urNp a/converter/ppm/ppmtoeyuv.c b/converter/ppm/ppmtoeyuv.c
+--- a/converter/ppm/ppmtoeyuv.c	2025-02-03 09:24:28.330500563 +0100
++++ b/converter/ppm/ppmtoeyuv.c	2025-02-03 18:22:08.012087384 +0100
+@@ -117,6 +117,7 @@ chrominanceBlue(pixel const p) {
+ static void
+ createMultiplicationTables(pixval const maxval) {
  
 +    overflow_add(maxval, 1);
      MALLOCARRAY_NOFAIL(mult299   , maxval+1);
      MALLOCARRAY_NOFAIL(mult587   , maxval+1);
      MALLOCARRAY_NOFAIL(mult114   , maxval+1);
-diff -ruNp a/converter/ppm/ppmtolj.c b/converter/ppm/ppmtolj.c
---- a/converter/ppm/ppmtolj.c	2021-06-02 15:53:59.846205765 +0200
-+++ b/converter/ppm/ppmtolj.c	2021-06-02 20:23:21.821634361 +0200
-@@ -182,6 +182,7 @@ int main(int argc, char *argv[]) {
-     ppm_readppminit( ifp, &cols, &rows, &maxval, &format );
-     pixelrow = ppm_allocrow( cols );
+diff -urNp a/converter/ppm/ppmtolj.c b/converter/ppm/ppmtolj.c
+--- a/converter/ppm/ppmtolj.c	2025-02-03 09:24:28.330500563 +0100
++++ b/converter/ppm/ppmtolj.c	2025-02-03 18:24:55.523489226 +0100
+@@ -212,6 +212,8 @@ printRaster(FILE *       const ifP,
+         pm_error("Image is uncomputably wide (%u columns)", cols);
+     }
  
 +    overflow2(cols, 6);
++
      obuf = (unsigned char *) pm_allocrow(cols * 3, sizeof(unsigned char));
      cbuf = (unsigned char *) pm_allocrow(cols * 6, sizeof(unsigned char));
-     if (mode == C_TRANS_MODE_DELTA)
-diff -ruNp a/converter/ppm/ppmtomitsu.c b/converter/ppm/ppmtomitsu.c
---- a/converter/ppm/ppmtomitsu.c	2021-06-02 15:53:59.846205765 +0200
-+++ b/converter/ppm/ppmtomitsu.c	2021-06-02 20:23:21.822634370 +0200
-@@ -685,6 +685,8 @@ main(int argc, char * argv[]) {
+ 
+diff -urNp a/converter/ppm/ppmtomitsu.c b/converter/ppm/ppmtomitsu.c
+--- a/converter/ppm/ppmtomitsu.c	2025-02-03 09:24:28.331500558 +0100
++++ b/converter/ppm/ppmtomitsu.c	2025-02-03 18:27:10.691006400 +0100
+@@ -68,6 +68,8 @@ mediaSize(const char * const media,
          medias = MSize_User;
  
      if (dpi300) {
@@ -1239,1378 +473,144 @@ diff -ruNp a/converter/ppm/ppmtomitsu.c b/converter/ppm/ppmtomitsu.c
          medias.maxcols *= 2;
          medias.maxrows *= 2;
      }
-diff -ruNp a/converter/ppm/ppmtopcx.c b/converter/ppm/ppmtopcx.c
---- a/converter/ppm/ppmtopcx.c	2021-06-02 15:53:59.846205765 +0200
-+++ b/converter/ppm/ppmtopcx.c	2021-06-02 20:23:21.823634378 +0200
-@@ -31,13 +31,13 @@
- #define PCX_MAXVAL      (pixval)255
+diff -urNp a/converter/ppm/ppmtopcx.c b/converter/ppm/ppmtopcx.c
+--- a/converter/ppm/ppmtopcx.c	2025-02-03 09:24:28.330500563 +0100
++++ b/converter/ppm/ppmtopcx.c	2025-02-03 18:31:08.699156362 +0100
+@@ -314,6 +314,8 @@ writeHeader(FILE *              const of
+     putbyte(0, ofP);                /* reserved byte                */
+     putbyte(planes, ofP);           /* number of color planes       */
  
++    overflow2(bitsPerPixel, cols);
++    overflow_add(bitsPerPixel * cols, 7);
+     bytesPerLine = ((cols * bitsPerPixel) + 7) / 8;
+     putword(bytesPerLine, ofP);    /* number of bytes per scanline */
  
--struct CmdlineInfo {
-+struct cmdlineInfo {
-     /* All the information the user supplied in the command line,
-        in a form easy for the program to use.
-     */
--    const char * inputFilespec;  /* '-' if stdin */
-+    const char *inputFilespec;  /* '-' if stdin */
-     unsigned int truecolor;   /* -24bit option */
--    unsigned int use8Bit; /* -8bit option */
-+    unsigned int use_8_bit; /* -8bit option */
-     unsigned int planes;    /* zero means minimum */
-     unsigned int packed;
-     unsigned int verbose;
-@@ -49,16 +49,16 @@ struct CmdlineInfo {
- 
- 
- 
--struct PcxCmapEntry {
-+struct pcxCmapEntry {
-     unsigned char r;
-     unsigned char g;
-     unsigned char b;
- };
- 
--static struct PcxCmapEntry
-+static struct pcxCmapEntry
- pcxCmapEntryFromPixel(pixel const colorPixel) {
- 
--    struct PcxCmapEntry retval;
-+    struct pcxCmapEntry retval;
- 
-     retval.r = PPM_GETR(colorPixel);
-     retval.g = PPM_GETG(colorPixel);
-@@ -70,8 +70,8 @@ pcxCmapEntryFromPixel(pixel const colorP
- 
- 
- static void
--parseCommandLine(int argc, const char ** argv,
--                 struct CmdlineInfo * const cmdlineP) {
-+parseCommandLine(int argc, char ** argv,
-+                 struct cmdlineInfo * const cmdlineP) {
- /*----------------------------------------------------------------------------
-    parse program command line described in Unix standard form by argc
-    and argv.  Return the information in the options as *cmdlineP.
-@@ -82,7 +82,7 @@ parseCommandLine(int argc, const char **
-    Note that the strings we return are stored in the storage that
-    was passed to us as the argv array.  We also trash *argv.
- -----------------------------------------------------------------------------*/
--    optEntry * option_def;
-+    optEntry *option_def;
-         /* Instructions to pm_optParseOptions3 on how to parse our options.
-          */
-     optStruct3 opt;
-@@ -97,7 +97,7 @@ parseCommandLine(int argc, const char **
-     OPTENT3(0, "24bit",     OPT_FLAG,   NULL,
-             &cmdlineP->truecolor,    0);
-     OPTENT3(0, "8bit",      OPT_FLAG,   NULL,
--            &cmdlineP->use8Bit,    0);
-+            &cmdlineP->use_8_bit,    0);
-     OPTENT3(0, "planes",    OPT_UINT,   &cmdlineP->planes,
-             &planesSpec,             0);
-     OPTENT3(0, "packed",    OPT_FLAG,   NULL,
-@@ -115,7 +115,7 @@ parseCommandLine(int argc, const char **
-     opt.short_allowed = FALSE;  /* We have no short (old-fashioned) options */
-     opt.allowNegNum = FALSE;  /* We have no parms that are negative numbers */
- 
--    pm_optParseOptions3( &argc, (char **)argv, opt, sizeof(opt), 0 );
-+    pm_optParseOptions3( &argc, argv, opt, sizeof(opt), 0 );
-         /* Uses and sets argc, argv, and some of *cmdline_p and others. */
- 
-     if (!xposSpec)
-@@ -141,7 +141,7 @@ parseCommandLine(int argc, const char **
-             pm_error("-planes is meaningless with -packed.");
-         if (cmdlineP->truecolor)
-             pm_error("-planes is meaningless with -24bit");
--        if (cmdlineP->use8Bit)
-+        if (cmdlineP->use_8_bit)
-             pm_error("-planes is meaningless with -8bit");
+diff -urNp a/converter/ppm/ppmtopict.c b/converter/ppm/ppmtopict.c
+--- a/converter/ppm/ppmtopict.c	2025-02-03 09:24:28.330500563 +0100
++++ b/converter/ppm/ppmtopict.c	2025-02-03 18:41:02.377096627 +0100
+@@ -394,6 +394,9 @@ writeRaster(FILE *          const ofP,
+         pm_error("Image is too wide (%u columns) for computation", cols);
      }
  
-@@ -151,7 +151,7 @@ parseCommandLine(int argc, const char **
-     if (!paletteSpec)
-         cmdlineP->palette = NULL;
- 
--    if (cmdlineP->use8Bit && cmdlineP->truecolor)
-+    if (cmdlineP->use_8_bit && cmdlineP->truecolor)
-         pm_error("You cannot specify both -8bit and -truecolor");
- 
-     if (argc-1 < 1)
-@@ -172,8 +172,8 @@ parseCommandLine(int argc, const char **
-  * Write out a two-byte little-endian word to the PCX file
-  */
- static void
--putword(unsigned int const w,
--        FILE *       const fp) {
-+Putword(int    const w,
-+        FILE * const fp) {
- 
-     int rc;
- 
-@@ -189,13 +189,12 @@ putword(unsigned int const w,
-  * Write out a byte to the PCX file
-  */
- static void
--putbyte(unsigned int const b,
--        FILE *       const ofP) {
-+Putbyte(int    const b,
-+        FILE * const fp) {
- 
-     int rc;
- 
--    rc = fputc(b & 0xff, ofP);
--
-+    rc = fputc(b & 0xff, fp);
-     if (rc == EOF)
-         pm_error("Error writing byte to output file.");
- }
-@@ -204,9 +203,9 @@ putbyte(unsigned int const b,
- 
- static void
- extractPlane(unsigned char * const rawrow,
--             unsigned int    const cols,
-+             int             const cols,
-              unsigned char * const buf,
--             unsigned int    const plane) {
-+             int             const plane) {
- /*----------------------------------------------------------------------------
-    From the image row 'rawrow', which is an array of 'cols' palette indices
-    (as unsigned 8 bit integers), extract plane number 'plane' and return
-@@ -224,7 +223,9 @@ extractPlane(unsigned char * const rawro
- 
-     cp = buf;  /* initial value */
- 
--    for (col = 0, cbit = 7, byteUnderConstruction = 0x00; col < cols; ++col) {
-+    cbit = 7;
-+    byteUnderConstruction = 0x00;
-+    for (col = 0; col < cols; ++col) {
-         if (rawrow[col] & planeMask)
-             byteUnderConstruction |= (1 << cbit);
- 
-@@ -246,17 +247,14 @@ extractPlane(unsigned char * const rawro
- 
- 
- static void
--packBits(unsigned char * const rawrow,
--         unsigned int    const width,
-+PackBits(unsigned char * const rawrow,
-+         int             const width,
-          unsigned char * const buf,
--         unsigned int    const bits) {
-+         int             const bits) {
- 
--    unsigned int x;
--    int i;
--    int shift;
-+    int x, i, shift;
- 
--    shift = -1;
--    i = -1;
-+    shift = i = -1;
- 
-     for (x = 0; x < width; ++x) {
-         if (shift < 0) {
-@@ -272,73 +270,71 @@ packBits(unsigned char * const rawrow,
- 
- 
- static void
--writeHeader(FILE *              const ofP,
--            unsigned int        const cols,
--            unsigned int        const rows,
--            unsigned int        const bitsPerPixel,
--            unsigned int        const planes,
--            struct PcxCmapEntry const cmap16[],
--            unsigned int        const xPos,
--            unsigned int        const yPos) {
--
--    unsigned int bytesPerLine;
--
--    putbyte(PCX_MAGIC, ofP);        /* .PCX magic number            */
--    putbyte(0x05, ofP);             /* PC Paintbrush version        */
--    putbyte(0x01, ofP);             /* .PCX run length encoding     */
--    putbyte(bitsPerPixel, ofP);     /* bits per pixel               */
--
--    putword(xPos, ofP);             /* x1   - image left            */
--    putword(yPos, ofP);             /* y1   - image top             */
--    putword(xPos+cols-1, ofP);      /* x2   - image right           */
--    putword(yPos+rows-1, ofP);      /* y2   - image bottom          */
--
--    putword(cols, ofP);             /* horizontal resolution        */
--    putword(rows, ofP);             /* vertical resolution          */
-+write_header(FILE *              const fp,
-+             int                 const cols,
-+             int                 const rows,
-+             int                 const BitsPerPixel,
-+             int                 const Planes,
-+             struct pcxCmapEntry const cmap16[],
-+             unsigned int        const xPos,
-+             unsigned int        const yPos) {
-+
-+    int i, BytesPerLine;
-+
-+    Putbyte(PCX_MAGIC, fp);        /* .PCX magic number            */
-+    Putbyte(0x05, fp);             /* PC Paintbrush version        */
-+    Putbyte(0x01, fp);             /* .PCX run length encoding     */
-+    Putbyte(BitsPerPixel, fp);     /* bits per pixel               */
-+
-+    Putword(xPos, fp);             /* x1   - image left            */
-+    Putword(yPos, fp);             /* y1   - image top             */
-+    Putword(xPos+cols-1, fp);      /* x2   - image right           */
-+    Putword(yPos+rows-1, fp);      /* y2   - image bottom          */
-+
-+    Putword(cols, fp);             /* horizontal resolution        */
-+    Putword(rows, fp);             /* vertical resolution          */
- 
-     /* Write out the Color Map for images with 16 colors or less */
--    if (cmap16) {
--        unsigned int i;
-+    if (cmap16)
-         for (i = 0; i < 16; ++i) {
--            putbyte(cmap16[i].r, ofP);
--            putbyte(cmap16[i].g, ofP);
--            putbyte(cmap16[i].b, ofP);
-+            Putbyte(cmap16[i].r, fp);
-+            Putbyte(cmap16[i].g, fp);
-+            Putbyte(cmap16[i].b, fp);
-         }
--    } else {
-+    else {
-         unsigned int i;
-         for (i = 0; i < 16; ++i) {
--            putbyte(0, ofP);
--            putbyte(0, ofP);
--            putbyte(0, ofP);
-+            Putbyte(0, fp);
-+            Putbyte(0, fp);
-+            Putbyte(0, fp);
-         }
-     }
--    putbyte(0, ofP);                /* reserved byte                */
--    putbyte(planes, ofP);           /* number of color planes       */
-+    Putbyte(0, fp);                /* reserved byte                */
-+    Putbyte(Planes, fp);           /* number of color planes       */
- 
--    bytesPerLine = ((cols * bitsPerPixel) + 7) / 8;
--    putword(bytesPerLine, ofP);    /* number of bytes per scanline */
-+    BytesPerLine = ((cols * BitsPerPixel) + 7) / 8;
-+    Putword(BytesPerLine, fp);    /* number of bytes per scanline */
- 
--    putword(1, ofP);                /* palette info                 */
-+    Putword(1, fp);                /* palette info                 */
- 
-     {
-         unsigned int i;
-         for (i = 0; i < 58; ++i)        /* fill to end of header        */
--            putbyte(0, ofP);
-+            Putbyte(0, fp);
-     }
- }
- 
- 
- 
- static void
--pcxEncode(FILE *                const ofP,
-+PCXEncode(FILE *                const fp,
-           const unsigned char * const buf,
--          unsigned int          const size) {
-+          int                   const Size) {
- 
--    const unsigned char * const end = buf + size;
-+    const unsigned char * const end = buf + Size;
- 
-     const unsigned char * currentP;
--    unsigned int          previous;
--    unsigned int          count;
-+    int previous, count;
- 
-     currentP = buf;
-     previous = *currentP++;
-@@ -351,19 +347,19 @@ pcxEncode(FILE *                const of
-         else {
-             if (count > 1 || (previous & 0xc0) == 0xc0) {
-                 count |= 0xc0;
--                putbyte ( count , ofP );
-+                Putbyte ( count , fp );
-             }
--            putbyte(previous, ofP);
-+            Putbyte(previous, fp);
-             previous = c;
--            count = 1;
-+            count   = 1;
-         }
-     }
- 
-     if (count > 1 || (previous & 0xc0) == 0xc0) {
-         count |= 0xc0;
--        putbyte(count, ofP);
-+        Putbyte ( count , fp );
-     }
--    putbyte(previous, ofP);
-+    Putbyte(previous, fp);
- }
- 
- 
-@@ -390,46 +386,63 @@ indexOfColor(colorhash_table const cht,
- 
- 
- static void
--writeRaster16Color(FILE * const ofP,
--                   pixel **            const pixels,
--                   unsigned int        const cols,
--                   unsigned int        const rows,
--                   unsigned int        const planes,
--                   colorhash_table     const cht,
--                   bool                const packbits,
--                   unsigned int        const bitsPerPixel) {
--
--    unsigned int const bytesPerLine = ((cols * bitsPerPixel) + 7) / 8;
--
--    unsigned char * indexRow;  /* malloc'ed */
--    /* indexRow[x] is the palette index of the pixel at column x of
--       the row currently being processed
--    */
--    unsigned char * planesrow; /* malloc'ed */
--    /* This is the input for a single row to the compressor */
-+ppmTo16ColorPcx(pixel **            const pixels,
-+                int                 const cols,
-+                int                 const rows,
-+                struct pcxCmapEntry const pcxcmap[],
-+                int                 const colors,
-+                colorhash_table     const cht,
-+                bool                const packbits,
-+                unsigned int        const planesRequested,
-+                unsigned int        const xPos,
-+                unsigned int        const yPos) {
- 
--    unsigned int row;
-+    int Planes, BytesPerLine, BitsPerPixel;
-+    unsigned char *indexRow;  /* malloc'ed */
-+        /* indexRow[x] is the palette index of the pixel at column x of
-+           the row currently being processed
-+        */
-+    unsigned char *planesrow; /* malloc'ed */
-+        /* This is the input for a single row to the compressor */
-+    int row;
- 
-+    if (packbits) {
-+        Planes = 1;
-+        if (colors > 4)        BitsPerPixel = 4;
-+        else if (colors > 2)   BitsPerPixel = 2;
-+        else                   BitsPerPixel = 1;
-+    } else {
-+        BitsPerPixel = 1;
-+        if (planesRequested)
-+            Planes = planesRequested;
-+        else {
-+            if (colors > 8)        Planes = 4;
-+            else if (colors > 4)   Planes = 3;
-+            else if (colors > 2)   Planes = 2;
-+            else                   Planes = 1;
-+        }
-+    }
-+    overflow2(BitsPerPixel, cols);
-+    overflow_add(BitsPerPixel * cols, 7);
-+    BytesPerLine = ((cols * BitsPerPixel) + 7) / 8;
-     MALLOCARRAY_NOFAIL(indexRow, cols);
--    MALLOCARRAY(planesrow, bytesPerLine);
--
--    if (!planesrow)
--        pm_error("Failed to allocate buffer for a line of %u bytes",
--                 bytesPerLine);
-+    MALLOCARRAY_NOFAIL(planesrow, BytesPerLine);
- 
-+    write_header(stdout, cols, rows, BitsPerPixel, Planes, pcxcmap,
-+                 xPos, yPos);
-     for (row = 0; row < rows; ++row) {
--        unsigned int col;
-+        int col;
-         for (col = 0; col < cols; ++col)
-             indexRow[col] = indexOfColor(cht, pixels[row][col]);
- 
-         if (packbits) {
--            packBits(indexRow, cols, planesrow, bitsPerPixel);
--            pcxEncode(ofP, planesrow, bytesPerLine);
-+            PackBits(indexRow, cols, planesrow, BitsPerPixel);
-+            PCXEncode(stdout, planesrow, BytesPerLine);
-         } else {
-             unsigned int plane;
--            for (plane = 0; plane < planes; ++plane) {
-+            for (plane = 0; plane < Planes; ++plane) {
-                 extractPlane(indexRow, cols, planesrow, plane);
--                pcxEncode(stdout, planesrow, bytesPerLine);
-+                PCXEncode(stdout, planesrow, BytesPerLine);
-             }
-         }
-     }
-@@ -439,143 +452,84 @@ writeRaster16Color(FILE * const ofP,
- 
- 
- 
--static void
--ppmTo16ColorPcx(pixel **            const pixels,
--                unsigned int        const cols,
--                unsigned int        const rows,
--                struct PcxCmapEntry const pcxcmap[],
--                unsigned int        const colorCt,
--                colorhash_table     const cht,
--                bool                const packbits,
--                unsigned int        const planesRequested,
--                unsigned int        const xPos,
--                unsigned int        const yPos) {
--
--    unsigned int planes;
--    unsigned int bitsPerPixel;
--
--    if (packbits) {
--        planes = 1;
--        if (colorCt > 4)        bitsPerPixel = 4;
--        else if (colorCt > 2)   bitsPerPixel = 2;
--        else                    bitsPerPixel = 1;
--    } else {
--        bitsPerPixel = 1;
--        if (planesRequested)
--            planes = planesRequested;
--        else {
--            if (colorCt > 8)        planes = 4;
--            else if (colorCt > 4)   planes = 3;
--            else if (colorCt > 2)   planes = 2;
--            else                   planes = 1;
--        }
--    }
--
--    writeHeader(stdout, cols, rows, bitsPerPixel, planes, pcxcmap,
--                xPos, yPos);
--
--    writeRaster16Color(stdout, pixels, cols, rows, planes, cht, packbits,
--                       bitsPerPixel);
--}
--
--
--
- static void
- ppmTo256ColorPcx(pixel **            const pixels,
--                 unsigned int        const cols,
--                 unsigned int        const rows,
--                 struct PcxCmapEntry const pcxcmap[],
--                 unsigned int        const colorCt,
-+                 int                 const cols,
-+                 int                 const rows,
-+                 struct pcxCmapEntry const pcxcmap[],
-+                 int                 const colors,
-                  colorhash_table     const cht,
-                  unsigned int        const xPos,
-                  unsigned int        const yPos) {
- 
--    unsigned char * rawrow;
--    unsigned int    row;
--
--    MALLOCARRAY(rawrow, cols);
-+    int row;
-+    unsigned int i;
-+    unsigned char *rawrow;
- 
--    if (!rawrow)
--        pm_error("Failed to allocate a buffer for %u columns", cols);
-+    rawrow = (unsigned char *)pm_allocrow(cols, sizeof(unsigned char));
- 
-     /* 8 bits per pixel, 1 plane */
--    writeHeader(stdout, cols, rows, 8, 1, NULL, xPos, yPos);
-+    write_header(stdout, cols, rows, 8, 1, NULL, xPos, yPos);
-     for (row = 0; row < rows; ++row) {
--        unsigned int col;
-+        int col;
-         for (col = 0; col < cols; ++col)
-             rawrow[col] = indexOfColor(cht, pixels[row][col]);
--        pcxEncode(stdout, rawrow, cols);
--
-+        PCXEncode(stdout, rawrow, cols);
-     }
--    putbyte(PCX_256_COLORS, stdout);
--
--    {
--        unsigned int i;
--
--        for (i = 0; i < MAXCOLORS; ++i) {
--            putbyte(pcxcmap[i].r, stdout);
--            putbyte(pcxcmap[i].g, stdout);
--            putbyte(pcxcmap[i].b, stdout);
--        }
-+    Putbyte(PCX_256_COLORS, stdout);
-+    for (i = 0; i < MAXCOLORS; ++i) {
-+        Putbyte(pcxcmap[i].r, stdout);
-+        Putbyte(pcxcmap[i].g, stdout);
-+        Putbyte(pcxcmap[i].b, stdout);
-     }
--    free(rawrow);
-+    pm_freerow((void*)rawrow);
- }
- 
- 
- 
- static void
- ppmToTruecolorPcx(pixel **     const pixels,
--                  unsigned int const cols,
--                  unsigned int const rows,
-+                  int          const cols,
-+                  int          const rows,
-                   pixval       const maxval,
-                   unsigned int const xPos,
-                   unsigned int const yPos) {
- 
--    unsigned char * redrow;
--    unsigned char * grnrow;
--    unsigned char * blurow;
--    unsigned int    row;
-+    unsigned char *redrow, *greenrow, *bluerow;
-+    int col, row;
- 
--    MALLOCARRAY(redrow, cols);
--    MALLOCARRAY(grnrow, cols);
--    MALLOCARRAY(blurow, cols);
--
--    if (!redrow || !grnrow || !blurow)
--        pm_error("Unable to allocate buffer for a row of %u pixels", cols);
-+    redrow   = (unsigned char *)pm_allocrow(cols, sizeof(unsigned char));
-+    greenrow = (unsigned char *)pm_allocrow(cols, sizeof(unsigned char));
-+    bluerow  = (unsigned char *)pm_allocrow(cols, sizeof(unsigned char));
- 
-     /* 8 bits per pixel, 3 planes */
--    writeHeader(stdout, cols, rows, 8, 3, NULL, xPos, yPos);
--
--    for (row = 0; row < rows; ++row) {
--        pixel * const pixrow = pixels[row];
--
--        unsigned int col;
--
--        for (col = 0; col < cols; ++col) {
--            pixel const pix = pixrow[col];
--
--            if (maxval != PCX_MAXVAL) {
--                redrow[col] = (long)PPM_GETR(pix) * PCX_MAXVAL / maxval;
--                grnrow[col] = (long)PPM_GETG(pix) * PCX_MAXVAL / maxval;
--                blurow[col] = (long)PPM_GETB(pix) * PCX_MAXVAL / maxval;
--            } else {
--                redrow[col] = PPM_GETR(pix);
--                grnrow[col] = PPM_GETG(pix);
--                blurow[col] = PPM_GETB(pix);
-+    write_header(stdout, cols, rows, 8, 3, NULL, xPos, yPos);
-+    for( row = 0; row < rows; row++ ) {
-+        register pixel *pP = pixels[row];
-+        for( col = 0; col < cols; col++, pP++ ) {
-+            if( maxval != PCX_MAXVAL ) {
-+                redrow[col]   = (long)PPM_GETR(*pP) * PCX_MAXVAL / maxval;
-+                greenrow[col] = (long)PPM_GETG(*pP) * PCX_MAXVAL / maxval;
-+                bluerow[col]  = (long)PPM_GETB(*pP) * PCX_MAXVAL / maxval;
-+            }
-+            else {
-+                redrow[col]   = PPM_GETR(*pP);
-+                greenrow[col] = PPM_GETG(*pP);
-+                bluerow[col]  = PPM_GETB(*pP);
-             }
-         }
--        pcxEncode(stdout, redrow, cols);
--        pcxEncode(stdout, grnrow, cols);
--        pcxEncode(stdout, blurow, cols);
-+        PCXEncode(stdout, redrow, cols);
-+        PCXEncode(stdout, greenrow, cols);
-+        PCXEncode(stdout, bluerow, cols);
-     }
--    free(blurow);
--    free(grnrow);
--    free(redrow);
-+    pm_freerow((void*)bluerow);
-+    pm_freerow((void*)greenrow);
-+    pm_freerow((void*)redrow);
- }
- 
- 
- 
--static const struct PcxCmapEntry
-+static const struct pcxCmapEntry
- stdPalette[] = {
-     {   0,   0,   0 },
-     {   0,   0, 170 },
-@@ -653,19 +607,20 @@ putPcxColorInHash(colorhash_table const
- 
- 
- static void
--generateStandardPalette(struct PcxCmapEntry ** const pcxcmapP,
-+generateStandardPalette(struct pcxCmapEntry ** const pcxcmapP,
-                         pixval                 const maxval,
-                         colorhash_table *      const chtP,
--                        unsigned int *         const colorsP) {
-+                        int *                  const colorsP) {
- 
-     unsigned int const stdPaletteSize = 16;
--
--    unsigned int          colorIndex;
--    struct PcxCmapEntry * pcxcmap;
--    colorhash_table       cht;
-+    unsigned int colorIndex;
-+    struct pcxCmapEntry * pcxcmap;
-+    colorhash_table cht;
- 
-     MALLOCARRAY_NOFAIL(pcxcmap, MAXCOLORS);
- 
-+    *pcxcmapP = pcxcmap;
-+
-     cht = ppm_alloccolorhash();
- 
-     for (colorIndex = 0; colorIndex < stdPaletteSize; ++colorIndex) {
-@@ -692,7 +647,6 @@ generateStandardPalette(struct PcxCmapEn
-         pcxcmap[colorIndex].b = 0;
-     }
- 
--    *pcxcmapP = pcxcmap;
-     *chtP = cht;
-     *colorsP = stdPaletteSize;
- }
-@@ -721,10 +675,11 @@ readPpmPalette(const char *   const pale
-                  *paletteSizeP, MAXCOLORS);
- 
-     {
--        unsigned int j;
--        unsigned int row;
--        for (row = 0, j = 0; row < rows; ++row) {
--            unsigned int col;
-+        int j;
-+        int row;
-+        j = 0;  /* initial value */
-+        for (row = 0; row < rows; ++row) {
-+            int col;
-             for (col = 0; col < cols; ++col)
-                 (*ppmPaletteP)[j++] = pixels[row][col];
-         }
-@@ -735,16 +690,16 @@ readPpmPalette(const char *   const pale
- 
- 
- static void
--readPaletteFromFile(struct PcxCmapEntry ** const pcxcmapP,
-+readPaletteFromFile(struct pcxCmapEntry ** const pcxcmapP,
-                     const char *           const paletteFileName,
-                     pixval                 const maxval,
-                     colorhash_table *      const chtP,
--                    unsigned int *         const colorsP) {
-+                    int *                  const colorsP) {
- 
-     unsigned int colorIndex;
-     pixel ppmPalette[MAXCOLORS];
-     unsigned int paletteSize;
--    struct PcxCmapEntry * pcxcmap;
-+    struct pcxCmapEntry * pcxcmap;
-     colorhash_table cht;
- 
-     readPpmPalette(paletteFileName, &ppmPalette, &paletteSize);
-@@ -777,7 +732,7 @@ readPaletteFromFile(struct PcxCmapEntry
- 
- static void
- moveBlackToIndex0(colorhist_vector const chv,
--                  unsigned int     const colorCt) {
-+                  int              const colors) {
- /*----------------------------------------------------------------------------
-    If black is in the palette, make it at Index 0.
- -----------------------------------------------------------------------------*/
-@@ -789,7 +744,7 @@ moveBlackToIndex0(colorhist_vector const
- 
-     blackPresent = FALSE;  /* initial assumption */
- 
--    for (i = 0; i < colorCt; ++i)
-+    for (i = 0; i < colors; ++i)
-         if (PPM_EQUAL(chv[i].color, blackPixel))
-             blackPresent = TRUE;
- 
-@@ -798,11 +753,10 @@ moveBlackToIndex0(colorhist_vector const
-            beginning of the table and if the color is already elsewhere in
-            the table, removes it.
-         */
--        int colorCt2;
--
--        colorCt2 = colorCt;
--        ppm_addtocolorhist(chv, &colorCt2, MAXCOLORS, &blackPixel, 0, 0);
--        assert(colorCt2 == colorCt);
-+        int colors2;
-+        colors2 = colors;
-+        ppm_addtocolorhist(chv, &colors2, MAXCOLORS, &blackPixel, 0, 0);
-+        assert(colors2 == colors);
-     }
- }
- 
-@@ -810,12 +764,12 @@ moveBlackToIndex0(colorhist_vector const
- 
- static void
- makePcxColormapFromImage(pixel **               const pixels,
--                         unsigned int           const cols,
--                         unsigned int           const rows,
-+                         int                    const cols,
-+                         int                    const rows,
-                          pixval                 const maxval,
--                         struct PcxCmapEntry ** const pcxcmapP,
-+                         struct pcxCmapEntry ** const pcxcmapP,
-                          colorhash_table *      const chtP,
--                         unsigned int *         const colorCtP,
-+                         int *                  const colorsP,
-                          bool *                 const tooManyColorsP) {
- /*----------------------------------------------------------------------------
-    Make a colormap (palette) for the PCX header that can be used
-@@ -831,29 +785,29 @@ makePcxColormapFromImage(pixel **
-    Iff there are too many colors to do that (i.e. more than 256),
-    return *tooManyColorsP == TRUE.
- -----------------------------------------------------------------------------*/
--    int colorCt;
-+    int colors;
-     colorhist_vector chv;
- 
-     pm_message("computing colormap...");
- 
--    chv = ppm_computecolorhist(pixels, cols, rows, MAXCOLORS, &colorCt);
-+    chv = ppm_computecolorhist(pixels, cols, rows, MAXCOLORS, &colors);
-     if (chv == NULL)
-         *tooManyColorsP = TRUE;
-     else {
--        unsigned int i;
--        struct PcxCmapEntry * pcxcmap;
-+        int i;
-+        struct pcxCmapEntry * pcxcmap;
- 
-         *tooManyColorsP = FALSE;
- 
--        pm_message("%d colors found", colorCt);
-+        pm_message("%d colors found", colors);
- 
--        moveBlackToIndex0(chv, colorCt);
-+        moveBlackToIndex0(chv, colors);
- 
-         MALLOCARRAY_NOFAIL(pcxcmap, MAXCOLORS);
- 
-         *pcxcmapP = pcxcmap;
- 
--        for (i = 0; i < colorCt; ++i) {
-+        for (i = 0; i < colors; ++i) {
-             pixel p;
- 
-             PPM_DEPTH(p, chv[i].color, maxval, PCX_MAXVAL);
-@@ -870,9 +824,9 @@ makePcxColormapFromImage(pixel **
-             pcxcmap[i].b = 0;
-         }
- 
--        *chtP = ppm_colorhisttocolorhash(chv, colorCt);
-+        *chtP = ppm_colorhisttocolorhash(chv, colors);
- 
--        *colorCtP = colorCt;
-+        *colorsP = colors;
- 
-         ppm_freecolorhist(chv);
-     }
-@@ -882,43 +836,43 @@ makePcxColormapFromImage(pixel **
- 
- static void
- ppmToPalettePcx(pixel **            const pixels,
--                unsigned int        const cols,
--                unsigned int        const rows,
-+                int                 const cols,
-+                int                 const rows,
-                 pixval              const maxval,
-                 unsigned int        const xPos,
-                 unsigned int        const yPos,
--                struct PcxCmapEntry const pcxcmap[],
-+                struct pcxCmapEntry const pcxcmap[],
-                 colorhash_table     const cht,
--                unsigned int        const colorCt,
-+                int                 const colors,
-                 bool                const packbits,
-                 unsigned int        const planes,
--                bool                const use8Bit) {
-+                bool                const use_8_bit) {
- 
-     /* convert image */
--    if (colorCt <= 16 && !use8Bit )
--        ppmTo16ColorPcx(pixels, cols, rows, pcxcmap, colorCt, cht,
-+    if( colors <= 16 && !use_8_bit )
-+        ppmTo16ColorPcx(pixels, cols, rows, pcxcmap, colors, cht,
-                         packbits, planes, xPos, yPos);
-     else
--        ppmTo256ColorPcx(pixels, cols, rows, pcxcmap, colorCt, cht,
-+        ppmTo256ColorPcx(pixels, cols, rows, pcxcmap, colors, cht,
-                          xPos, yPos);
- }
- 
- 
- 
- int
--main(int argc, const char *argv[]) {
-+main(int argc, char *argv[]) {
- 
--    struct CmdlineInfo cmdline;
--    FILE * ifP;
-+    struct cmdlineInfo cmdline;
-+    FILE* ifP;
-     int rows, cols;
-     pixval maxval;
-     pixel **pixels;
--    struct PcxCmapEntry * pcxcmap;
-+    struct pcxCmapEntry * pcxcmap;
-     colorhash_table cht;
-     bool truecolor;
--    unsigned int colorCt;
-+    int colors;
- 
--    pm_proginit(&argc, argv);
-+    ppm_init(&argc, argv);
- 
-     parseCommandLine(argc, argv, &cmdline);
- 
-@@ -931,15 +885,15 @@ main(int argc, const char *argv[]) {
-     else {
-         if (cmdline.stdpalette) {
-             truecolor = FALSE;
--            generateStandardPalette(&pcxcmap, maxval, &cht, &colorCt);
-+            generateStandardPalette(&pcxcmap, maxval, &cht, &colors);
-         } else if (cmdline.palette) {
-             truecolor = FALSE;
-             readPaletteFromFile(&pcxcmap, cmdline.palette, maxval,
--                                &cht, &colorCt);
-+                                &cht, &colors);
-         } else {
-             bool tooManyColors;
-             makePcxColormapFromImage(pixels, cols, rows, maxval,
--                                     &pcxcmap, &cht, &colorCt,
-+                                     &pcxcmap, &cht, &colors,
-                                      &tooManyColors);
- 
-             if (tooManyColors) {
-@@ -958,8 +912,8 @@ main(int argc, const char *argv[]) {
-     else {
-         ppmToPalettePcx(pixels, cols, rows, maxval,
-                         cmdline.xpos, cmdline.ypos,
--                        pcxcmap, cht, colorCt, cmdline.packed,
--                        cmdline.planes, cmdline.use8Bit);
-+                        pcxcmap, cht, colors, cmdline.packed,
-+                        cmdline.planes, cmdline.use_8_bit);
- 
-         ppm_freecolorhash(cht);
-         free(pcxcmap);
-diff -ruNp a/converter/ppm/ppmtopict.c b/converter/ppm/ppmtopict.c
---- a/converter/ppm/ppmtopict.c	2021-06-02 15:53:59.846205765 +0200
-+++ b/converter/ppm/ppmtopict.c	2021-06-02 20:23:21.824634387 +0200
-@@ -450,6 +450,8 @@ main(int argc, const char ** argv) {
-     putShort(stdout, 0);            /* mode */
- 
-     /* Finally, write out the data. */
 +    overflow_add(cols/MAX_COUNT, 1);
 +    overflow_add(cols, cols/MAX_COUNT+1);
-     outBuf = malloc((unsigned)(cols+cols/MAX_COUNT+1));
-     for (row = 0, oc = 0; row < rows; ++row) {
-         unsigned int rowSize;
-diff -ruNp a/converter/ppm/ppmtopj.c b/converter/ppm/ppmtopj.c
---- a/converter/ppm/ppmtopj.c	2021-06-02 15:53:59.845205755 +0200
-+++ b/converter/ppm/ppmtopj.c	2021-06-02 20:23:21.824634387 +0200
-@@ -179,6 +179,7 @@ char *argv[];
- 	pixels = ppm_readppm( ifp, &cols, &rows, &maxval );
- 
- 	pm_close( ifp );
-+        overflow2(cols,2);
- 	obuf = (unsigned char *) pm_allocrow(cols, sizeof(unsigned char));
- 	cbuf = (unsigned char *) pm_allocrow(cols * 2, sizeof(unsigned char));
- 
-diff -ruNp a/converter/ppm/ppmtopjxl.c b/converter/ppm/ppmtopjxl.c
---- a/converter/ppm/ppmtopjxl.c	2021-06-02 15:53:59.845205755 +0200
-+++ b/converter/ppm/ppmtopjxl.c	2021-06-02 20:23:21.825634396 +0200
-@@ -267,6 +267,9 @@ main(int argc, const char * argv[]) {
++
+     MALLOCARRAY(outBuf, cols + cols/MAX_COUNT + 1);
+     if (!outBuf)
+         pm_error("Unable to allocate %u-byte row buffer",
+diff -urNp a/converter/ppm/ppmtopjxl.c b/converter/ppm/ppmtopjxl.c
+--- a/converter/ppm/ppmtopjxl.c	2025-02-03 09:24:28.331500558 +0100
++++ b/converter/ppm/ppmtopjxl.c	2025-02-03 18:48:46.550503012 +0100
+@@ -535,6 +535,8 @@ main(int argc, const char * argv[]) {
+         pm_error("image too large; reduce with ppmscale");
      if (maxval > PCL_MAXVAL)
          pm_error("color range too large; reduce with ppmcscale");
- 
 +    if (cols < 0 || rows < 0)
 +        pm_error("negative size is not possible");
-+
-     /* Figure out the colormap. */
-     pm_message("Computing colormap...");
-     chv = ppm_computecolorhist(pixels, cols, rows, MAXCOLORS, &colors);
-@@ -286,6 +289,8 @@ main(int argc, const char * argv[]) {
-         case 0: /* direct mode (no palette) */
-             bpp = bitsperpixel(maxval); /* bits per pixel */
-             bpg = bpp; bpb = bpp;
-+            overflow2(bpp, 3);
-+            overflow_add(bpp*3, 7);
-             bpp = (bpp*3+7)>>3;     /* bytes per pixel now */
-             bpr = (bpp<<3)-bpg-bpb; 
-             bpp *= cols;            /* bytes per row now */
-@@ -295,9 +300,13 @@ main(int argc, const char * argv[]) {
-         case 3: case 7: pclindex++;
-         default:
-             bpp = 8/pclindex;
-+            overflow_add(cols, bpp);
-+            if(bpp == 0)
-+                pm_error("assert: no bpp");
-             bpp = (cols+bpp-1)/bpp;      /* bytes per row */
-         }
-     }
-+    overflow2(bpp,2);
-     inrow = (char *)malloc((unsigned)bpp);
-     outrow = (char *)malloc((unsigned)bpp*2);
-     runcnt = (signed char *)malloc((unsigned)bpp);
-diff -ruNp a/converter/ppm/ppmtowinicon.c b/converter/ppm/ppmtowinicon.c
---- a/converter/ppm/ppmtowinicon.c	2021-06-02 15:53:59.845205755 +0200
-+++ b/converter/ppm/ppmtowinicon.c	2021-06-02 20:23:21.825634396 +0200
-@@ -12,6 +12,7 @@
  
+     computeColormap(pixels, cols, rows, MAXCOLORS, &chv, &cht, &colorCt);
+ 
+diff -urNp a/converter/ppm/ppmtowinicon.c b/converter/ppm/ppmtowinicon.c
+--- a/converter/ppm/ppmtowinicon.c	2025-02-03 09:24:28.330500563 +0100
++++ b/converter/ppm/ppmtowinicon.c	2025-02-03 18:56:25.509890831 +0100
+@@ -14,6 +14,7 @@
+ #include <assert.h>
  #include <math.h>
  #include <string.h>
 +#include <stdlib.h>
  
  #include "pm_c_util.h"
  #include "winico.h"
-@@ -214,6 +215,7 @@ createAndBitmap (gray ** const ba, int c
-    MALLOCARRAY_NOFAIL(rowData, rows);
-    icBitmap->xBytes = xBytes;
-    icBitmap->data   = rowData;
-+   overflow2(xBytes, rows);
-    icBitmap->size   = xBytes * rows;
-    for (y=0;y<rows;y++) {
-       u1 * row;
-@@ -342,6 +344,7 @@ create4Bitmap (pixel ** const pa, int co
-    MALLOCARRAY_NOFAIL(rowData, rows);
-    icBitmap->xBytes = xBytes;
-    icBitmap->data   = rowData;
-+   overflow2(xBytes, rows);
-    icBitmap->size   = xBytes * rows;
- 
-    for (y=0;y<rows;y++) {
-@@ -402,6 +405,7 @@ create8Bitmap (pixel ** const pa, int co
-    MALLOCARRAY_NOFAIL(rowData, rows);
-    icBitmap->xBytes = xBytes;
-    icBitmap->data   = rowData;
-+   overflow2(xBytes, rows);
-    icBitmap->size   = xBytes * rows;
- 
-    for (y=0;y<rows;y++) {
-@@ -709,7 +713,11 @@ addEntryToIcon(MS_Ico       const MSIcon
-     entry->bitcount      = bpp;
-     entry->ih            = createInfoHeader(entry, xorBitmap, andBitmap);
-     entry->colors        = palette->colors;
--    entry->size_in_bytes = 
-+    overflow2(4, entry->color_count);
-+    overflow_add(xorBitmap->size, andBitmap->size);
-+    overflow_add(xorBitmap->size + andBitmap->size, 40);
-+    overflow_add(xorBitmap->size + andBitmap->size + 40, 4 * entry->color_count);
-+    entry->size_in_bytes =
-         xorBitmap->size + andBitmap->size + 40 + (4 * entry->color_count);
-     if (verbose) 
-         pm_message("entry->size_in_bytes = %d + %d + %d = %d",
-diff -ruNp a/converter/ppm/ppmtoxpm.c b/converter/ppm/ppmtoxpm.c
---- a/converter/ppm/ppmtoxpm.c	2021-06-02 15:53:59.846205765 +0200
-+++ b/converter/ppm/ppmtoxpm.c	2021-06-02 20:23:21.826634405 +0200
-@@ -198,6 +198,7 @@ genNumstr(unsigned int const input, int
+@@ -207,6 +208,7 @@ newAndBitmap(gray **      const ba,
+     MALLOCARRAY_NOFAIL(rowData, rows);
+     icBitmapP->xBytes = xByteCt;
+     icBitmapP->data   = rowData;
++    overflow2(xByteCt, rows);
+     icBitmapP->size   = xByteCt * rows;
+     for (row = 0; row < rows; ++row) {
+         u1 * thisRow;  /* malloc'ed */
+@@ -706,6 +708,11 @@ addEntryToIcon(MS_Ico *     const MSIcon
+     /* all the icons I looked at ignored this value */
+     entryP->ih            = newInfoHeader(*entryP);
+     entryP->colors        = paletteP->colors;
++    overflow2(4, entryCols);
++    overflow_add(xorBitmapP->size, andBitmapP->size);
++    overflow_add(xorBitmapP->size + andBitmapP->size, 40);
++    overflow_add(xorBitmapP->size + andBitmapP->size + 40, 4 * entryCols);
++
+     entryP->size_in_bytes =
+         xorBitmapP->size + andBitmapP->size + 40 + (4 * entryCols);
+     if (verbose)
+diff -urNp a/converter/ppm/ppmtoxpm.c b/converter/ppm/ppmtoxpm.c
+--- a/converter/ppm/ppmtoxpm.c	2025-02-03 09:24:28.329500569 +0100
++++ b/converter/ppm/ppmtoxpm.c	2025-02-03 18:59:21.646266347 +0100
+@@ -193,6 +193,7 @@ numstr(unsigned int const input,
      unsigned int i;
  
      /* Allocate memory for printed number.  Abort if error. */
-+    overflow_add(digits, 1);
-     if (!(str = (char *) malloc(digits + 1)))
-         pm_error("out of memory");
++    overflow_add(digitCt, 1);
+     MALLOCARRAY_NOFAIL(str, digitCt + 1);
  
-@@ -315,6 +316,7 @@ genCmap(colorhist_vector const chv,
-     unsigned int charsPerPixel;
-     unsigned int xpmMaxval;
-     
+     i = input; /* initial value */
+@@ -296,6 +297,7 @@ genCmap(colorhist_vector const chv,
+    Return as *charsPerPixel the number of characters, or digits, that
+    will be needed in the XPM raster to form an index into this color map.
+ -----------------------------------------------------------------------------*/
 +    if (includeTransparent) overflow_add(ncolors, 1);
-     MALLOCARRAY(cmap, cmapSize);
-     if (cmapP == NULL)
-         pm_error("Out of memory allocating %u bytes for a color map.",
-diff -ruNp a/converter/ppm/qrttoppm.c b/converter/ppm/qrttoppm.c
---- a/converter/ppm/qrttoppm.c	2021-06-02 15:53:59.846205765 +0200
-+++ b/converter/ppm/qrttoppm.c	2021-06-02 20:23:21.826634405 +0200
-@@ -46,7 +46,7 @@ main( argc, argv )
+     unsigned int const cmapSize = ncolors + (includeTransparent ? 1 : 0);
  
-     ppm_writeppminit( stdout, cols, rows, maxval, 0 );
-     pixelrow = ppm_allocrow( cols );
--    buf = (unsigned char *) malloc( 3 * cols );
-+    buf = (unsigned char *) malloc2( 3 , cols );
-     if ( buf == (unsigned char *) 0 )
- 	pm_error( "out of memory" );
+     CixelMap * cmap;  /* malloc'ed */
+diff -urNp a/converter/ppm/qrttoppm.c b/converter/ppm/qrttoppm.c
+--- a/converter/ppm/qrttoppm.c	2025-02-03 09:24:28.331500558 +0100
++++ b/converter/ppm/qrttoppm.c	2025-02-03 19:00:16.846070585 +0100
+@@ -51,6 +51,7 @@ main(int argc, const char ** argv) {
  
-diff -ruNp a/converter/ppm/sldtoppm.c b/converter/ppm/sldtoppm.c
---- a/converter/ppm/sldtoppm.c	2021-06-02 15:53:59.845205755 +0200
-+++ b/converter/ppm/sldtoppm.c	2021-06-02 20:23:21.827634413 +0200
-@@ -154,127 +154,85 @@ vscale(int * const px,
+     pixelrow = ppm_allocrow(cols);
  
++    overflow2(cols, 3);
+     MALLOCARRAY(buf, 3 * cols);
  
- 
--static void
--upcase(const char * const sname,
--       char *       const uname) {
--
--    unsigned int i;
--    const char * ip;
--
--    for (i = 0, ip = sname; i < 31; ++i) {
--        char const ch = *ip++;
--
--        if (ch != EOS)
--            uname[i] = islower(ch) ? toupper(ch) : ch;
--    }
--    uname[i] = EOS;
--}
--
--
--
--static void
--skipBytes(FILE *       const fileP,
--          unsigned int const count) {
--
--    unsigned int i;
--
--    for (i = 0; i < count; ++i)
--        getc(fileP);
--}
--
--
--
--static void
--scanDirectory(FILE *       const slFileP,
--              long         const dirPos,
--              bool         const dirOnly,
--              const char * const uname,
--              bool *       const foundP) {
--/*----------------------------------------------------------------------------
--   Scan the directory at the current position in *slFileP, either listing
--   the directory ('dirOnly' true) or searching for a slide named
--   'uname' ('dirOnly' false).
--
--   'dirPos' is the offset in the file of the directory, i.e. the current
--   position of *slFileP.
--
--   In the latter case, return as *foundP whether the slide name is there.
-------------------------------------------------------------------------------*/
--    bool found;
--    bool eof;
--    long pos;
--    unsigned char libent[36];
--
--    for (found = false, eof = false, pos = dirPos; !found && !eof; ) {
--        size_t readCt;
--        readCt = fread(libent, 36, 1, slFileP);
--        if (readCt != 1)
--            eof = true;
--        else {
--            /* The directory entry is 32 bytes of NUL-terminated slide name
--               followed by 4 bytes of offset of the next directory entry.
--            */
--            const char * const slideName = (const char *)(&libent[0]);
--            if (pm_strnlen(slideName, 32) == 32)
--                pm_error("Invalid input: slide name field is not "
--                         "nul-terminated");
--            else {
--                if (strlen(slideName) == 0)
--                    eof = true;
--                else {
--                    pos += 36;
--                    if (dirOnly) {
--                        pm_message("  %s", slideName);
--                    } else if (streq(slideName, uname)) {
--                        long const dpos =
--                            (((((libent[35] << 8) | libent[34]) << 8) |
--                              libent[33]) << 8) | libent[32];
--
--                        if ((slFileP == stdin) ||
--                            (fseek(slFileP, dpos, 0) == -1)) {
--
--                            skipBytes(slFileP, dpos - pos);
--                        }
--                        found = true;
--                    }
--                }
--            }
--        }
--    }
--    *foundP = found;
--}
--
- /*  SLIDEFIND  --  Find  a  slide  in  a  library  or,  if  DIRONLY is
-            nonzero, print a directory listing of the  library.
-            If  UCASEN  is nonzero, the requested slide name is
-            converted to upper case. */
- 
- static void
--slidefind(const char * const slideName,
--          bool         const dirOnly,
-+slidefind(const char * const sname,
-+          bool         const dironly,
-           bool         const ucasen) {
- 
--    char uname[32];  /* upper case translation of 'slideName' */
--    char header[32]; /* (supposed) header read from file */
-+    char uname[32];
-+    unsigned char libent[36];
-+    long pos;
-     bool found;
-+    bool eof;
- 
--    if (dirOnly)
-+    if (dironly)
-         pm_message("Slides in library:");
-     else {
--        upcase(slideName, uname);
-+        unsigned int i;
-+        const char * ip;
-+        
-+        ip = sname; /* initial value */
-+        
-+        for (i = 0; i < 31; ++i) {
-+            char const ch = *ip++;
-+            if (ch == EOS)
-+                break;
-+
-+            {
-+                char const upperCh =
-+                    ucasen && islower(ch) ? toupper(ch) : ch;
-+                
-+                uname[i] = upperCh;
-+            }
-+        }
-+        uname[i] = EOS;
-     }
- 
-     /* Read slide library header and verify. */
--
--    if ((fread(header, 32, 1, slfile) != 1) ||
--        (!STRSEQ(header, "AutoCAD Slide Library 1.0\r\n\32"))) {
-+    
-+    if ((fread(libent, 32, 1, slfile) != 1) ||
-+        (!streq((char *)libent, "AutoCAD Slide Library 1.0\015\012\32"))) {
-         pm_error("not an AutoCAD slide library file.");
-     }
-+    pos = 32;
-+    
-+    /* Search for a slide with the requested name or list the directory */
-+    
-+    for (found = false, eof = false; !found && !eof; ) {
-+        size_t readCt;
-+        readCt = fread(libent, 36, 1, slfile);
-+        if (readCt != 1)
-+            eof = true;
-+        else if (strlen((char *)libent) == 0)
-+            eof = true;
-+    }
-+    if (!eof) {
-+        pos += 36;
-+        if (dironly) {
-+            pm_message("  %s", libent);
-+        } else if (streq((char *)libent, uname)) {
-+            long dpos;
-+
-+            dpos = (((((libent[35] << 8) | libent[34]) << 8) |
-+                     libent[33]) << 8) | libent[32];
-+
-+            if ((slfile == stdin) || (fseek(slfile, dpos, 0) == -1)) {
-+                dpos -= pos;
-+        
-+                while (dpos-- > 0)
-+                    getc(slfile);
-+            }
-+            found = true;
-+        }
-+    }
- 
--    scanDirectory(slfile, 32, dirOnly, ucasen ? uname : slideName, &found);
--
--    if (!found && !dirOnly)
--        pm_error("slide '%s' not in library.", slideName);
-+    if (!found && !dironly)
-+        pm_error("slide '%s' not in library.", sname);
- }
- 
- 
-@@ -392,7 +350,7 @@ slider(slvecfn   slvec,
- 
-     /* Verify that slide format is compatible with this program. */
- 
--    if (!STRSEQ(slfrof.slh, slhi.slh))
-+    if (streq(slfrof.slh, slhi.slh))
-         pm_error("this is not an AutoCAD slide file.");
- 
-     /* Verify that the number format and file level in the header  are
-@@ -506,6 +464,8 @@ slider(slvecfn   slvec,
+     if (!buf)
+diff -urNp a/converter/ppm/sldtoppm.c b/converter/ppm/sldtoppm.c
+--- a/converter/ppm/sldtoppm.c	2025-02-03 09:24:28.330500563 +0100
++++ b/converter/ppm/sldtoppm.c	2025-02-03 19:02:13.580656717 +0100
+@@ -542,6 +542,8 @@ slider(slvecfn         slvec,
  
      /* Allocate image buffer and clear it to black. */
  
 +    overflow_add(ixdots, 1);
 +    overflow_add(iydots, 1);
-     pixels = ppm_allocarray(pixcols = ixdots + 1, pixrows = iydots + 1);
-     PPM_ASSIGN(rgbcolor, 0, 0, 0);
-     ppmd_filledrectangle(pixels, pixcols, pixrows, pixmaxval, 0, 0,
-diff -ruNp a/converter/ppm/ximtoppm.c b/converter/ppm/ximtoppm.c
---- a/converter/ppm/ximtoppm.c	2021-06-02 15:53:59.846205765 +0200
-+++ b/converter/ppm/ximtoppm.c	2021-06-02 20:23:21.828634422 +0200
-@@ -22,9 +22,7 @@
- #include "shhopt.h"
- #include "nstring.h"
+     pixcols = ixdots + 1;
+     pixrows = iydots + 1;
+     pixels = ppm_allocarray(pixcols, pixrows);
+diff -urNp a/converter/ppm/ximtoppm.c b/converter/ppm/ximtoppm.c
+--- a/converter/ppm/ximtoppm.c	2025-02-03 09:24:28.330500563 +0100
++++ b/converter/ppm/ximtoppm.c	2025-02-03 19:06:57.979648387 +0100
+@@ -204,8 +204,7 @@ readImageChannel(FILE *         const if
+             }
+             /* return to the beginning of the next image's buffer */
+             if (fseek(ifP, marker, 0) == -1) {
+-                pm_message("ReadImageChannel: can't fseek to location "
+-                           "in image buffer");
++                pm_message("ReadImageChannel: can't fseek to location in image buffer");
+                 return 0;
+             }
+             free(line);
+diff -urNp a/editor/pamcut.c b/editor/pamcut.c
+--- a/editor/pamcut.c	2025-02-03 09:24:28.296500747 +0100
++++ b/editor/pamcut.c	2025-02-04 09:20:22.743237833 +0100
+@@ -833,6 +833,8 @@ cutOneImage(FILE *             const ifP
+     } else {
+         outpam = inpam;    /* Initial value -- most fields should be same */
+         outpam.file   = ofP;
++        overflow_add(rightcol, 1);
++        overflow_add(bottomrow, 1);
+         outpam.width  = rightcol - leftcol + 1;
+         outpam.height = bottomrow - toprow + 1;
  
--
--
--struct CmdlineInfo {
-+struct cmdlineInfo {
-     /* All the information the user supplied in the command line,
-        in a form easy for the program to use.
-     */
-@@ -36,8 +34,8 @@ struct CmdlineInfo {
- 
- 
- static void
--parseCommandLine(int argc, const char ** argv,
--                 struct CmdlineInfo *cmdlineP) {
-+parseCommandLine(int argc, char ** argv,
-+                 struct cmdlineInfo *cmdlineP) {
- /*----------------------------------------------------------------------------
-    Note that many of the strings that this function returns in the
-    *cmdlineP structure are actually in the supplied argv array.  And
-@@ -59,7 +57,7 @@ parseCommandLine(int argc, const char **
-     opt.short_allowed = FALSE;  /* We have no short (old-fashioned) options */
-     opt.allowNegNum = FALSE;  /* We have no parms that are negative numbers */
- 
--    pm_optParseOptions3(&argc, (char**)argv, opt, sizeof(opt), 0);
-+    pm_optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
-         /* Uses and sets argc, argv, and all of *cmdlineP. */
- 
-     if (!alphaoutSpec)
-@@ -102,11 +100,6 @@ ReadXimHeader(FILE *     const in_fp,
-         pm_message("ReadXimHeader: unable to read file header" );
-         return(0);
-     }
--    /* Force broken ASCIIZ strings to at least be valid ASCIIZ */
--    a_head.author [sizeof(a_head.author)  - 1] = '\0';
--    a_head.date   [sizeof(a_head.date)    - 1] = '\0';
--    a_head.program[sizeof(a_head.program) - 1] = '\0';
--
-     if (atoi(a_head.header_size) != sizeof(ImageHeader)) {
-         pm_message("ReadXimHeader: header size mismatch" );
-         return(0);
-@@ -120,15 +113,39 @@ ReadXimHeader(FILE *     const in_fp,
-     header->ncolors = atoi(a_head.num_colors);
-     header->nchannels = atoi(a_head.num_channels);
-     header->bytes_per_line = atoi(a_head.bytes_per_line);
--#if 0
--    header->npics = atoi(a_head.num_pictures);
--#endif
-+/*    header->npics = atoi(a_head.num_pictures);
-+*/
-     header->bits_channel = atoi(a_head.bits_per_channel);
-     header->alpha_flag = atoi(a_head.alpha_channel);
--    header->author = pm_strdup(a_head.author);
--    header->date = pm_strdup(a_head.date);
--    header->program = pm_strdup(a_head.program);
--
-+    if (strlen(a_head.author)) {
-+        overflow_add(strlen(a_head.author),1);
-+        if (!(header->author = calloc((unsigned int)strlen(a_head.author)+1,
-+                1))) {
-+            pm_message("ReadXimHeader: can't calloc author string" );
-+            return(0);
-+        }
-+    header->width = atoi(a_head.image_width);
-+        strncpy(header->author, a_head.author, strlen(a_head.author));
-+    }
-+    if (strlen(a_head.date)) {
-+        overflow_add(strlen(a_head.date),1);
-+        if (!(header->date =calloc((unsigned int)strlen(a_head.date)+1,1))){
-+            pm_message("ReadXimHeader: can't calloc date string" );
-+            return(0);
-+        }
-+    header->width = atoi(a_head.image_width);
-+        strncpy(header->date, a_head.date, strlen(a_head.date));
-+    }
-+    if (strlen(a_head.program)) {
-+        overflow_add(strlen(a_head.program),1);
-+        if (!(header->program = calloc(
-+                    (unsigned int)strlen(a_head.program) + 1, 1))) {
-+            pm_message("ReadXimHeader: can't calloc program string" );
-+            return(0);
-+        }
-+    header->width = atoi(a_head.image_width);
-+        strncpy(header->program, a_head.program,strlen(a_head.program));
-+    }
-     /* Do double checking for backwards compatibility */
-     if (header->npics == 0)
-         header->npics = 1;
-@@ -147,6 +164,7 @@ ReadXimHeader(FILE *     const in_fp,
-     if (header->nchannels == 3 && header->bits_channel == 8)
-         header->ncolors = 0;
-     else if (header->nchannels == 1 && header->bits_channel == 8) {
-+        overflow2(header->ncolors, sizeof(Color));
-         header->colors = (Color *)calloc((unsigned int)header->ncolors,
-                 sizeof(Color));
-         if (header->colors == NULL) {
-@@ -197,8 +215,7 @@ ReadImageChannel(FILE *         const in
-         }
-         /* return to the beginning of the next image's buffer */
-         if (fseek(infp, marker, 0) == -1) {
--            pm_message("ReadImageChannel: can't fseek to location "
--                       "in image buffer");
-+            pm_message("ReadImageChannel: can't fseek to location in image buffer" );
-             return(0);
-         }
-         free((char *)line);
-@@ -307,26 +324,28 @@ ReadXimImage(FILE *     const in_fp,
- ***********************************************************************/
- 
- static int
--ReadXim(FILE *     const in_fp,
--        XimImage * const xim) {
--
-+ReadXim(in_fp, xim)
-+    FILE *in_fp;
-+    XimImage *xim;
-+{
-     if (!ReadXimHeader(in_fp, xim)) {
-         pm_message("can't read xim header" );
--        return 0;
--    } else if (!ReadXimImage(in_fp, xim)) {
-+    return(0);
-+    }
-+    if (!ReadXimImage(in_fp, xim)) {
-         pm_message("can't read xim data" );
--        return 0;
--    } else
--        return 1;
-+    return(0);
-+    }
-+    return(1);
- }
- 
- 
- 
- int
--main(int          argc,
--     const char **argv) {
-+main(int argc,
-+     char *argv[]) {
- 
--    struct CmdlineInfo cmdline;
-+    struct cmdlineInfo cmdline;
-     FILE *ifP, *imageout_file, *alpha_file;
-     XimImage xim;
-     pixel *pixelrow, colormap[256];
-@@ -338,7 +357,7 @@ main(int          argc,
-     pixval maxval;
-     bool success;
- 
--    pm_proginit(&argc, argv);
-+    ppm_init(&argc, argv);
- 
-     parseCommandLine(argc, argv, &cmdline);
- 
-diff -ruNp a/editor/pamcut.c b/editor/pamcut.c
---- a/editor/pamcut.c	2021-06-02 15:53:59.809205409 +0200
-+++ b/editor/pamcut.c	2021-06-02 20:23:21.828634422 +0200
-@@ -799,6 +799,8 @@ cutOneImage(FILE *             const ifP
- 
-     outpam = inpam;    /* Initial value -- most fields should be same */
-     outpam.file   = ofP;
-+    overflow_add(rightcol, 1);
-+    overflow_add(bottomrow, 1);
-     outpam.width  = rightcol - leftcol + 1;
-     outpam.height = bottomrow - toprow + 1;
- 
-diff -ruNp a/editor/pnmgamma.c b/editor/pnmgamma.c
---- a/editor/pnmgamma.c	2021-06-02 15:53:59.805205371 +0200
-+++ b/editor/pnmgamma.c	2021-06-02 20:23:21.829634431 +0200
+diff -urNp a/editor/pnmgamma.c b/editor/pnmgamma.c
+--- a/editor/pnmgamma.c	2025-02-03 09:24:28.296500747 +0100
++++ b/editor/pnmgamma.c	2025-02-04 09:21:03.587045507 +0100
 @@ -596,6 +596,7 @@ createGammaTables(enum transferFunction
                    xelval **             const btableP) {
  
@@ -2619,10 +619,10 @@ diff -ruNp a/editor/pnmgamma.c b/editor/pnmgamma.c
      MALLOCARRAY(*rtableP, maxval+1);
      MALLOCARRAY(*gtableP, maxval+1);
      MALLOCARRAY(*btableP, maxval+1);
-diff -ruNp a/editor/pnmhisteq.c b/editor/pnmhisteq.c
---- a/editor/pnmhisteq.c	2021-06-02 15:53:59.800205323 +0200
-+++ b/editor/pnmhisteq.c	2021-06-02 20:23:21.829634431 +0200
-@@ -107,6 +107,7 @@ computeLuminosityHistogram(xel * const *
+diff -urNp a/editor/pnmhisteq.c b/editor/pnmhisteq.c
+--- a/editor/pnmhisteq.c	2025-02-03 09:24:28.296500747 +0100
++++ b/editor/pnmhisteq.c	2025-02-04 09:21:41.957864812 +0100
+@@ -106,6 +106,7 @@ computeLuminosityHistogram(xel * const *
      unsigned int pixelCount;
      unsigned int * lumahist;
  
@@ -2630,11 +630,10 @@ diff -ruNp a/editor/pnmhisteq.c b/editor/pnmhisteq.c
      MALLOCARRAY(lumahist, maxval + 1);
      if (lumahist == NULL)
          pm_error("Out of storage allocating array for %u histogram elements",
-diff --git a/editor/pnmpad.c b/editor/pnmpad.c
-index 9fa9f9e..6b98204 100644
---- a/editor/pnmpad.c
-+++ b/editor/pnmpad.c
-@@ -654,6 +654,8 @@ main(int argc, const char ** argv) {
+diff -urNp a/editor/pnmpad.c b/editor/pnmpad.c
+--- a/editor/pnmpad.c	2025-02-03 09:24:28.299500730 +0100
++++ b/editor/pnmpad.c	2025-02-04 09:22:39.237595043 +0100
+@@ -1127,6 +1127,8 @@ main(int argc, const char ** argv) {
  
      computePadSizes(cmdline, cols, rows, &lpad, &rpad, &tpad, &bpad);
  
@@ -2643,17 +642,17 @@ index 9fa9f9e..6b98204 100644
      newcols = cols + lpad + rpad;
  
      if (cmdline.reportonly)
-diff -ruNp a/editor/pnmremap.c b/editor/pnmremap.c
---- a/editor/pnmremap.c	2021-06-02 15:53:59.809205409 +0200
-+++ b/editor/pnmremap.c	2021-06-02 20:23:21.830634440 +0200
-@@ -470,6 +470,7 @@ fserr_init(struct pam *   const pamP,
- 
-     unsigned int const fserrSize = pamP->width + 2;
+diff -urNp a/editor/pnmremap.c b/editor/pnmremap.c
+--- a/editor/pnmremap.c	2025-02-03 09:24:28.296500747 +0100
++++ b/editor/pnmremap.c	2025-02-04 09:42:44.340919042 +0100
+@@ -468,6 +468,7 @@ fserr_init(struct pam *   const pamP,
+ -----------------------------------------------------------------------------*/
+     unsigned int plane;
  
 +    overflow_add(pamP->width, 2);
-     fserrP->width = pamP->width;
+     unsigned int const fserrSz = pamP->width + 2;
  
-     MALLOCARRAY(fserrP->thiserr, pamP->depth);
+     fserrP->width = pamP->width;
 @@ -508,6 +509,7 @@ floydInitRow(struct pam *   const pamP,
  
      unsigned int col;
@@ -2662,98 +661,82 @@ diff -ruNp a/editor/pnmremap.c b/editor/pnmremap.c
      for (col = 0; col < pamP->width + 2; ++col) {
          unsigned int plane;
          for (plane = 0; plane < pamP->depth; ++plane)
-diff -ruNp a/editor/pnmscalefixed.c b/editor/pnmscalefixed.c
---- a/editor/pnmscalefixed.c	2021-06-02 15:53:59.800205323 +0200
-+++ b/editor/pnmscalefixed.c	2021-06-02 20:23:21.830634440 +0200
-@@ -214,6 +214,7 @@ compute_output_dimensions(const struct c
+diff -urNp a/editor/pnmscalefixed.c b/editor/pnmscalefixed.c
+--- a/editor/pnmscalefixed.c	2025-02-03 09:24:28.299500730 +0100
++++ b/editor/pnmscalefixed.c	2025-02-04 09:49:53.152275133 +0100
+@@ -215,6 +215,7 @@ compute_output_dimensions(const struct c
                            const int rows, const int cols,
                            int * newrowsP, int * newcolsP) {
  
 +    overflow2(rows, cols);
      if (cmdline.pixels) {
-         if (rows * cols <= cmdline.pixels) {
+         if (rows <= cmdline.pixels / cols) {
              *newrowsP = rows;
-@@ -265,6 +266,8 @@ compute_output_dimensions(const struct c
- 
-     if (*newcolsP < 1) *newcolsP = 1;
-     if (*newrowsP < 1) *newrowsP = 1;
-+
-+    overflow2(*newcolsP, *newrowsP);
- }        
- 
- 
-@@ -446,6 +449,9 @@ main(int argc, char **argv ) {
-        unfilled.  We can address that by stretching, whereas the other
-        case would require throwing away some of the input.
-     */
+@@ -222,6 +223,8 @@ compute_output_dimensions(const struct c
+         } else {
+             const double scale =
+                 sqrt( (float) cmdline.pixels / ((float) cols * (float) rows));
++            overflow2(rows, scale);
++            overflow2(scale, cols);
+             *newrowsP = rows * scale;
+             *newcolsP = cols * scale;
+         }
+@@ -455,6 +458,9 @@ main(int argc, char **argv ) {
+         pm_error("New image width (%d) is uncomputably large", newcols);
+     if (newrows > INT_MAX / SCALE)
+         pm_error("New image height (%d) is uncomputably large", newrows);
 +
 +    overflow2(newcols, SCALE);
 +    overflow2(newrows, SCALE);
      sxscale = SCALE * newcols / cols;
      syscale = SCALE * newrows / rows;
  
-diff -ruNp a/editor/ppmdither.c b/editor/ppmdither.c
---- a/editor/ppmdither.c	2021-06-02 15:53:59.803205352 +0200
-+++ b/editor/ppmdither.c	2021-06-02 20:23:21.831634448 +0200
-@@ -356,6 +356,11 @@ dithMatrix(unsigned int const dithPower)
-             (dithDim * sizeof(*dithMat)) + /* pointers */
-             (dithDim * dithDim * sizeof(**dithMat)); /* data */
-         
-+
-+        overflow2(dithDim, sizeof(*dithMat));
-+        overflow3(dithDim, dithDim, sizeof(**dithMat));
-+        overflow_add(dithDim * sizeof(*dithMat), dithDim * dithDim * sizeof(**dithMat));
-+
-         dithMat = malloc(dithMatSize);
-         
-         if (dithMat == NULL) 
-diff -ruNp a/editor/specialty/pamoil.c b/editor/specialty/pamoil.c
---- a/editor/specialty/pamoil.c	2021-06-02 15:53:59.817205486 +0200
-+++ b/editor/specialty/pamoil.c	2021-06-02 20:23:21.831634448 +0200
-@@ -112,6 +112,7 @@ main(int argc, char *argv[] ) {
-     tuples = pnm_readpam(ifp, &inpam, PAM_STRUCT_SIZE(tuple_type));
-     pm_close(ifp);
+diff -urNp a/editor/specialty/pamoil.c b/editor/specialty/pamoil.c
+--- a/editor/specialty/pamoil.c	2025-02-03 09:24:28.301500720 +0100
++++ b/editor/specialty/pamoil.c	2025-02-04 09:56:21.543650456 +0100
+@@ -185,6 +185,7 @@ main(int argc, const char ** argv) {
+ 
+     tuples = pnm_readpam(ifP, &inpam, PAM_STRUCT_SIZE(tuple_type));
  
 +    overflow_add(inpam.maxval, 1);
      MALLOCARRAY(hist, inpam.maxval + 1);
      if (hist == NULL)
          pm_error("Unable to allocate memory for histogram.");
-diff -ruNp a/lib/libpam.c b/lib/libpam.c
---- a/lib/libpam.c	2021-06-02 15:53:59.867205967 +0200
-+++ b/lib/libpam.c	2021-06-02 20:23:21.832634457 +0200
-@@ -225,7 +225,8 @@ allocPamRow(const struct pam * const pam
+diff -urNp a/lib/libpam.c b/lib/libpam.c
+--- a/lib/libpam.c	2025-02-03 09:24:28.326500585 +0100
++++ b/lib/libpam.c	2025-02-04 10:04:33.126859799 +0100
+@@ -258,6 +258,7 @@ allocPamRow(const struct pam * const pam
      unsigned int const bytesPerTuple = allocationDepth(pamP) * sizeof(sample);
      tuple * tuplerow;
  
--    tuplerow = malloc(pamP->width * (sizeof(tuple *) + bytesPerTuple));
 +    overflow_add(sizeof(tuple *), bytesPerTuple);
-+    tuplerow = malloc2(pamP->width, (sizeof(tuple *) + bytesPerTuple));
+     tuplerow = malloc(pamP->width * (sizeof(tuple *) + bytesPerTuple));
  
      if (tuplerow != NULL) {
-         /* Now we initialize the pointers to the individual tuples
-diff -ruNp a/lib/libpammap.c b/lib/libpammap.c
---- a/lib/libpammap.c	2021-06-02 15:53:59.867205967 +0200
-+++ b/lib/libpammap.c	2021-06-02 20:23:00.658449503 +0200
-@@ -108,6 +108,8 @@ allocTupleIntListItem(struct pam * const
-     */
-     struct tupleint_list_item * retval;
+diff -urNp a/lib/libpammap.c b/lib/libpammap.c
+--- a/lib/libpammap.c	2025-02-03 09:24:28.325500590 +0100
++++ b/lib/libpammap.c	2025-02-04 10:05:45.382614292 +0100
+@@ -111,6 +111,9 @@ allocTupleIntListItem(struct pam * const
+     if (pamP->depth > (UINT_MAX - sizeof(*retval)) / sizeof(sample))
+         pm_error("Depth %u is too large for computation", pamP->depth);
  
 +    overflow2(pamP->depth, sizeof(sample));
 +    overflow_add(sizeof(*retval)-sizeof(retval->tupleint.tuple), pamP->depth*sizeof(sample));
++
      unsigned int const size =
          sizeof(*retval) - sizeof(retval->tupleint.tuple)
          + pamP->depth * sizeof(sample);
-diff -ruNp a/lib/libpm.c b/lib/libpm.c
---- a/lib/libpm.c	2021-06-02 15:53:59.867205967 +0200
-+++ b/lib/libpm.c	2021-06-02 20:23:21.832634457 +0200
-@@ -888,5 +888,53 @@ pm_parse_height(const char * const arg)
-     return height;
+diff -urNp a/lib/libpm.c b/lib/libpm.c
+--- a/lib/libpm.c	2025-02-03 09:24:28.324500595 +0100
++++ b/lib/libpm.c	2025-02-04 10:27:02.795619696 +0100
+@@ -926,4 +926,52 @@ pm_parse_maxval(const char * const arg)
+     return maxval;
  }
  
 +/*
-+ *	Maths wrapping
++ * Maths wrapping
 + */
- 
++
 +void __overflow2(int a, int b)
 +{
 +        if(a < 0 || b < 0)
@@ -2791,21 +774,20 @@ diff -ruNp a/lib/libpm.c b/lib/libpm.c
 +                pm_error("Zero byte allocation");
 +        return malloc(a*b*c);
 +}
-+
 +void *realloc2(void * a, int b, int c)
 +{
-+        overflow2(b, c);
-+        if(b*c == 0)
++       overflow2(b, c);
++       if(b*c == 0)
 +                pm_error("Zero byte allocation");
 +        return realloc(a, b*c);
 +}
  
-diff -ruNp a/lib/pm.h b/lib/pm.h
---- a/lib/pm.h	2021-06-02 15:53:59.866205957 +0200
-+++ b/lib/pm.h	2021-06-02 20:23:21.833634466 +0200
-@@ -442,5 +442,12 @@ pm_parse_height(const char * const arg);
- }
- #endif
+diff -urNp a/lib/pm.h b/lib/pm.h
+--- a/lib/pm.h	2025-02-03 09:24:28.327500579 +0100
++++ b/lib/pm.h	2025-02-04 10:28:10.427411309 +0100
+@@ -439,6 +439,13 @@ pm_parse_height(const char * const arg);
+ unsigned int
+ pm_parse_maxval(const char * const arg);
  
 +void *malloc2(int, int);
 +void *malloc3(int, int, int);
@@ -2814,45 +796,58 @@ diff -ruNp a/lib/pm.h b/lib/pm.h
 +void overflow3(int, int, int);
 +void overflow_add(int, int);
 +
- 
+ #ifdef __cplusplus
+ }
  #endif
-diff -ruNp a/other/pnmcolormap.c b/other/pnmcolormap.c
---- a/other/pnmcolormap.c	2021-06-02 15:53:59.882206111 +0200
-+++ b/other/pnmcolormap.c	2021-06-02 20:23:21.833634466 +0200
-@@ -1002,6 +1002,7 @@ colormapToSquare(struct pam * const pamP
+diff -urNp a/other/pnmcolormap.c b/other/pnmcolormap.c
+--- a/other/pnmcolormap.c	2025-02-03 09:24:28.303500709 +0100
++++ b/other/pnmcolormap.c	2025-02-04 10:29:08.620231936 +0100
+@@ -1130,8 +1130,10 @@ colormapToSquare(struct pam * const pamP
+         unsigned int const intsqrt = (int)sqrt((float)colormap.size);
+         if (SQR(intsqrt) == colormap.size)
              pamP->width = intsqrt;
-         else
-             pamP->width = intsqrt + 1;
+-        else
++        else {
 +            overflow_add(intsqrt, 1);
+             pamP->width = intsqrt + 1;
++        }
      }
      {
          unsigned int const intQuotient = colormap.size / pamP->width;
-diff --git a/urt/Runput.c b/urt/Runput.c
-index 1a7f2f7..de2737b 100644
---- a/urt/Runput.c
-+++ b/urt/Runput.c
-@@ -202,6 +202,7 @@ RunSetup(rle_hdr * the_hdr)
-     if ( the_hdr->background != 0 )
-     {
-         int i;
-+        overflow_add(the_hdr->ncolors, 1);
-         rle_pixel *background =
-             (rle_pixel *)malloc( (unsigned)(the_hdr->ncolors + 1) );
-         int *bg_color;
-@@ -224,7 +225,7 @@ RunSetup(rle_hdr * the_hdr)
-         /* Big-endian machines are harder */
-         int i, nmap = (1 << the_hdr->cmaplen) *
-                                the_hdr->ncmap;
--        char *h_cmap = (char *)malloc( nmap * 2 );
-+        char *h_cmap = (char *)malloc2( nmap, 2 );
-         if ( h_cmap == NULL )
-         {
-             fprintf( stderr,
-diff --git a/urt/rle.h b/urt/rle.h
-index 1e7ddd0..df45dd9 100644
---- a/urt/rle.h
-+++ b/urt/rle.h
-@@ -152,6 +152,17 @@ rle_hdr             /* End of typedef. */
+diff -urNp a/urt/rle_addhist.c b/urt/rle_addhist.c
+--- a/urt/rle_addhist.c	2025-02-03 09:24:28.360500401 +0100
++++ b/urt/rle_addhist.c	2025-02-04 10:37:56.010607217 +0100
+@@ -52,6 +52,8 @@ newCommentLen(const char *  const histoi
+     for (i = 0; argv[i]; ++i) {
+         size_t const thisArgLen = strlen(argv[i]);
+         if (thisArgLen < UINT_MAX - length - 100) {
++            overflow_add(length, thisArgLen);
++            overflow_add(length+thisArgLen, 1);
+             length += thisArgLen;
+             length += 1;  /* For the space */
+         }
+@@ -61,10 +63,16 @@ newCommentLen(const char *  const histoi
+     length += strlen(timedate);
+ 
+     /* Add length of padding, "on ", and length of history name plus "="*/
++    overflow_add(strlen(padding), 4);
++    overflow_add(strlen(histoire), strlen(padding) + 4);
++    overflow_add(length, strlen(histoire) + strlen(padding) + 4);
+     length += strlen(padding) + 3 + strlen(histoire) + 1;
+ 
+-    if (old && *old)
++    overflow_add(length, 1);
++    if (old && *old) {
++        overflow_add(length, strlen(old));
+         length += strlen(old);       /* add length if there. */
++    }
+ 
+     ++length;     /* Add size of terminating NUL. */
+ 
+diff -urNp a/urt/rle.h b/urt/rle.h
+--- a/urt/rle.h	2025-02-03 09:24:28.360500401 +0100
++++ b/urt/rle.h	2025-02-04 10:33:12.842479585 +0100
+@@ -153,6 +153,17 @@ rle_hdr             /* End of typedef. *
   */
  extern rle_hdr rle_dflt_hdr;
  
@@ -2870,59 +865,9 @@ index 1e7ddd0..df45dd9 100644
  
  /* Declare RLE library routines. */
  
-diff --git a/urt/rle_addhist.c b/urt/rle_addhist.c
-index 45c3dbf..ef13973 100644
---- a/urt/rle_addhist.c
-+++ b/urt/rle_addhist.c
-@@ -70,13 +70,19 @@ rle_addhist(char *          argv[],
-         return;
- 
-     length = 0;
--    for (i = 0; argv[i]; ++i)
-+    for (i = 0; argv[i]; ++i) {
-+        overflow_add(length, strlen(argv[i]));
-+        overflow_add(length+1, strlen(argv[i]));
-         length += strlen(argv[i]) +1;   /* length of each arg plus space. */
-+    }
- 
-     time(&temp);
-     timedate = ctime(&temp);
-     length += strlen(timedate);        /* length of date and time in ASCII. */
- 
-+    overflow_add(strlen(padding), 4);
-+    overflow_add(strlen(histoire), strlen(padding) + 4);
-+    overflow_add(length, strlen(histoire) + strlen(padding) + 4);
-     length += strlen(padding) + 3 + strlen(histoire) + 1;
-         /* length of padding, "on "  and length of history name plus "="*/
-     if (in_hdr) /* if we are interested in the old comments... */
-@@ -84,8 +90,10 @@ rle_addhist(char *          argv[],
-     else
-         old = NULL;
- 
--    if (old && *old)
-+    if (old && *old) {
-+        overflow_add(length, strlen(old));
-         length += strlen(old);       /* add length if there. */
-+    }
- 
-     ++length;                               /*Cater for the null. */
- 
-diff --git a/urt/rle_getrow.c b/urt/rle_getrow.c
-index a24870a..0ba62c3 100644
---- a/urt/rle_getrow.c
-+++ b/urt/rle_getrow.c
-@@ -164,6 +164,7 @@ rle_get_setup(rle_hdr * const the_hdr) {
-         char * cp;
- 
-         VAXSHORT(comlen, infile); /* get comment length */
-+        overflow_add(comlen, 1);
-         evenlen = (comlen + 1) & ~1;    /* make it even */
-         if (evenlen) {
-             MALLOCARRAY(comment_buf, evenlen);
-diff --git a/urt/rle_hdr.c b/urt/rle_hdr.c
-index 8ceaa9e..4c13037 100644
---- a/urt/rle_hdr.c
-+++ b/urt/rle_hdr.c
+diff -urNp a/urt/rle_hdr.c b/urt/rle_hdr.c
+--- a/urt/rle_hdr.c	2025-02-03 09:24:28.360500401 +0100
++++ b/urt/rle_hdr.c	2025-02-04 10:42:11.745682618 +0100
 @@ -148,7 +148,7 @@ rle_hdr_cp(rle_hdr * const fromHdrP,
      if (toHdrP->cmap) {
          size_t const size =
@@ -2932,11 +877,12 @@ index 8ceaa9e..4c13037 100644
          if (!toHdrP->cmap)
              pm_error("Failed to allocate memory for %u color maps "
                       "of length %u", toHdrP->ncmap, 1 << toHdrP->cmaplen);
-@@ -164,11 +164,16 @@ rle_hdr_cp(rle_hdr * const fromHdrP,
+@@ -163,12 +163,16 @@ rle_hdr_cp(rle_hdr * const fromHdrP,
+         const char ** cp;
  
          /* Count the comments. */
-         for (cp = toHdrP->comments, size = 0; *cp; ++cp)
-+	{
+-        for (cp = toHdrP->comments, size = 0; *cp; ++cp)
++        for (cp = toHdrP->comments, size = 0; *cp; ++cp) {
 +            overflow_add(size,1);
              ++size;
 +        }
@@ -2949,22 +895,26 @@ index 8ceaa9e..4c13037 100644
              size *= sizeof(char *);
              toHdrP->comments = malloc(size);
              if (!toHdrP->comments)
-diff -ruNp a/urt/rle_putcom.c b/urt/rle_putcom.c
---- a/urt/rle_putcom.c	2021-06-02 15:53:59.824205554 +0200
-+++ b/urt/rle_putcom.c	2021-06-02 20:25:22.620707940 +0200
-@@ -98,12 +98,14 @@ rle_putcom(const char * const value,
-         const char * v;
-         const char ** old_comments;
-         int i;
--        for (i = 2, cp = the_hdr->comments; *cp != NULL; ++i, ++cp)
-+        for (i = 2, cp = the_hdr->comments; *cp != NULL; ++i, ++cp) {
+diff -urNp a/urt/rle_putcom.c b/urt/rle_putcom.c
+--- a/urt/rle_putcom.c	2025-02-03 09:24:28.360500401 +0100
++++ b/urt/rle_putcom.c	2025-02-04 10:43:04.472477242 +0100
+@@ -101,6 +101,7 @@ rle_putcom(const char * const value,
+         for (i = 2, cp = hdrP->comments;
+              *cp != NULL && i < UINT_MAX;
+              ++i, ++cp) {
 +            overflow_add(i, 1);
              if (match(value, *cp) != NULL) {
                  v = *cp;
                  *cp = value;
-                 return v;
-             }
-+        }
-         /* Not found */
-         /* Can't realloc because somebody else might be pointing to this
-          * comments block.  Of course, if this were true, then the
+diff -urNp a/urt/Runput.c b/urt/Runput.c
+--- a/urt/Runput.c	2025-02-03 09:24:28.360500401 +0100
++++ b/urt/Runput.c	2025-02-04 10:30:24.683997548 +0100
+@@ -236,7 +236,7 @@ RunSetup(rle_hdr * const hdrP) {
+         int * bg_color;
+ 
+         assert(hdrP->ncolors < UINT_MAX);
+-
++        overflow_add(hdrP->ncolors, 1);
+         MALLOCARRAY_NOFAIL(background, hdrP->ncolors + 1);
+ 
+         /* If even number of bg color bytes, put out one more to get to
diff --git a/netpbm-security-scripts.patch b/netpbm-security-scripts.patch
deleted file mode 100644
index 2730e5b..0000000
--- a/netpbm-security-scripts.patch
+++ /dev/null
@@ -1,119 +0,0 @@
-diff -urNp a/editor/ppmfade b/editor/ppmfade
---- a/editor/ppmfade	2022-06-28 07:58:59.195317750 +0200
-+++ b/editor/ppmfade	2022-06-28 08:04:56.070643056 +0200
-@@ -215,84 +215,84 @@ for ($i = 1; $i <= $nframes; $i++) {
-             $n = $spline20[$i] * 100;
-             system("ppmshift $n $tmpdir/junk1.ppm >$tmpdir/junk1a.ppm");
-             $n = (1-$spline20[$i-10])*100;
--            system("ppmshift $n junk2.ppm >junk2a.ppm");
-+            system("ppmshift $n $tmpdir/junk2.ppm >$tmpdir/junk2a.ppm");
-             $n = $spline10[$i-10];
--            system("ppmmix $n junk1a.ppm junk2a.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk1a.ppm $tmpdir/junk2a.ppm >$tmpdir/junk3.ppm");
-         } else {
-             my $n = (1-$spline20[$i-10]) * 100;
--            system("ppmshift $n junk2.ppm >junk3.ppm");
-+            system("ppmshift $n $tmpdir/junk2.ppm >$tmpdir/junk3.ppm");
-         }
-     } elsif ($mode eq $RELIEF) {
-         if ($i == 1) {
--            system("ppmrelief junk1.ppm >junk1r.ppm");
-+            system("ppmrelief $tmpdir/junk1.ppm >$tmpdir/junk1r.ppm");
-         }
-         if ($i <= 10) {
-             my $n = $spline10[$i];
--            system("ppmmix $n junk1.ppm junk1r.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk1.ppm $tmpdir/junk1r.ppm >$tmpdir/junk3.ppm");
-         } elsif ($i <= 20) {
-             my $n = $spline10[$i-10];
--            system("ppmmix $n junk1r.ppm junk2r.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk1r.ppm $tmpdir/junk2r.ppm >$tmpdir/junk3.ppm");
-         } else {
-             my $n = $spline10[$i-20];
--            system("ppmmix $n junk2r.ppm junk2.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk2r.ppm $tmpdir/junk2.ppm >$tmpdir/junk3.ppm");
-         }
-         if ($i == 10) {
--            system("ppmrelief junk2.ppm >junk2r.ppm");
-+            system("ppmrelief $tmpdir/junk2.ppm >$tmpdir/junk2r.ppm");
-         }
-     } elsif ($mode eq $OIL) {
-         if ($i == 1) {
--            system("ppmtopgm junk1.ppm | pgmoil >junko.ppm");
--            system("rgb3toppm junko.ppm junko.ppm junko.ppm " .
--                   ">junk1o.ppm");
-+            system("ppmtopgm $tmpdir/junk1.ppm | pgmoil >$tmpdir/junko.ppm");
-+            system("rgb3toppm $tmpdir/junko.ppm $tmpdir/junko.ppm $tmpdir/junko.ppm " .
-+                   ">$tmpdir/junk1o.ppm");
-         }
-         if ($i <= 10) {
-             my $n = $spline10[$i];
--            system("ppmmix $n junk1.ppm junk1o.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk1.ppm $tmpdir/junk1o.ppm >$tmpdir/junk3.ppm");
-         } elsif ($i <= 20) {
-             my $n = $spline10[$i-10];
--            system("ppmmix $n junk1o.ppm junk2o.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk1o.ppm $tmpdir/junk2o.ppm >$tmpdir/junk3.ppm");
-         } else {
-             my $n = $spline10[$i-20];
--            system("ppmmix $n junk2o.ppm junk2.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk2o.ppm $tmpdir/junk2.ppm >$tmpdir/junk3.ppm");
-         }
-         if ($i == 10) {
--            system("ppmtopgm junk2.ppm | pgmoil >junko.ppm");
--            system("rgb3toppm junko.ppm junko.ppm junko.ppm " .
--                   ">junk2o.ppm");
-+            system("ppmtopgm $tmpdir/junk2.ppm | pgmoil >$tmpdir/junko.ppm");
-+            system("rgb3toppm $tmpdir/junko.ppm $tmpdir/junko.ppm $tmpdir/junko.ppm " .
-+                   ">$tmpdir/junk2o.ppm");
-         }
-     } elsif ($mode eq $EDGE) {
-         if ($i == 1) {
--            system("ppmtopgm junk1.ppm | pgmedge >junko.ppm");
--            system("rgb3toppm junko.ppm junko.ppm junko.ppm " .
--                   ">junk1o.ppm");
-+            system("ppmtopgm $tmpdir/junk1.ppm | pgmedge >$tmpdir/junko.ppm");
-+            system("rgb3toppm $tmpdir/junko.ppm $tmpdir/junko.ppm $tmpdir/junko.ppm " .
-+                   ">$tmpdir/junk1o.ppm");
-         }
-         if ($i <= 10) {
-             my $n = $spline10[$i];
--            system("ppmmix $n junk1.ppm junk1o.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk1.ppm $tmpdir/junk1o.ppm >$tmpdir/junk3.ppm");
-         } elsif ($i <= 20) {
-             my $n = $spline10[$i-10];
--            system("ppmmix $n junk1o.ppm junk2o.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk1o.ppm $tmpdir/junk2o.ppm >$tmpdir/junk3.ppm");
-         } else {
-             my $n = $spline10[$i-20];
--            system("ppmmix $n junk2o.ppm junk2.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk2o.ppm $tmpdir/junk2.ppm >$tmpdir/junk3.ppm");
-         }
-         if ($i == 10) {
--            system("ppmtopgm junk2.ppm | pgmedge >junko.ppm");
--            system("rgb3toppm junko.ppm junko.ppm junko.ppm " .
--                   ">junk2o.ppm");
-+            system("ppmtopgm $tmpdir/junk2.ppm | pgmedge >$tmpdir/junko.ppm");
-+            system("rgb3toppm $tmpdir/junko.ppm $tmpdir/junko.ppm $tmpdir/junko.ppm " .
-+                   ">$tmpdir/junk2o.ppm");
-         } 
-     } elsif ($mode eq $BENTLEY) {
-         if ($i == 1) {
--            system("ppmtopgm junk1.ppm | pgmbentley >junko.ppm");
--            system("rgb3toppm junko.ppm junko.ppm junko.ppm " .
--                   ">junk1o.ppm");
-+            system("ppmtopgm $tmpdir/junk1.ppm | pgmbentley >$tmpdir/junko.ppm");
-+            system("rgb3toppm $tmpdir/junko.ppm $tmpdir/junko.ppm $tmpdir/junko.ppm " .
-+                   ">$tmpdir/junk1o.ppm");
-         }
-         if ($i <= 10) {
-             my $n = $spline10[$i];
--            system("ppmmix $n junk1.ppm junk1o.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk1.ppm $tmpdir/junk1o.ppm >$tmpdir/junk3.ppm");
-         } elsif ($i <= 20) {
-             my $n = $spline10[$i-10];
--            system("ppmmix $n junk1o.ppm junk2o.ppm >junk3.ppm");
-+            system("ppmmix $n $tmpdir/junk1o.ppm $tmpdir/junk2o.ppm >$tmpdir/junk3.ppm");
-         } else {
-             my $n = $spline10[$i-20];
-             system("ppmmix $n $tmpdir/junk2o.ppm $tmpdir/junk2.ppm " .
diff --git a/netpbm-shlib-ldflags.patch b/netpbm-shlib-ldflags.patch
new file mode 100644
index 0000000..ffad115
--- /dev/null
+++ b/netpbm-shlib-ldflags.patch
@@ -0,0 +1,13 @@
+diff --git a/config.mk.in b/config.mk.in
+index 50687ba..d35c982 100644
+--- a/config.mk.in
++++ b/config.mk.in
+@@ -250,7 +250,7 @@ EXE =
+ 
+ # Here, $(SONAME) resolves to the soname for the shared library being created.
+ # The following are gcc options.  This works on GNU libc systems.
+-LDSHLIB = -shared -Wl,-soname,$(SONAME)
++LDSHLIB = $(LDFLAGS) -shared -Wl,-soname,$(SONAME)
+ # You need -nostart instead of -shared on BeOS.  Though the BeOS compiler is
+ # ostensibly gcc, it has the -nostart option, which is not mentioned in gcc
+ # documentation and doesn't exist in at least one non-BeOS installation.
diff --git a/netpbm.spec b/netpbm.spec
index 5780cc7..110e827 100644
--- a/netpbm.spec
+++ b/netpbm.spec
@@ -1,9 +1,9 @@
 Summary:         A library for handling different graphics file formats
 Name:            netpbm
-Version:         11.02.00
+Version:         11.13.00
 Release:         1%{?dist}
 # See copyright_summary for details
-License:         BSD and GPLv2 and IJG and MIT and Public Domain
+License:         BSD-3-Clause AND GPL-2.0-only AND LGPL-2.1-or-later AND GPL-3.0-or-later AND IJG AND MIT AND NTP AND PostgreSQL AND LicenseRef-MIT-CRL-Xim AND LicenseRef-Fedora-Public-Domain
 URL: http://netpbm.sourceforge.net/
 # Source0 is prepared by
 # svn checkout https://svn.code.sf.net/p/netpbm/code/advanced netpbm-%%{version}
@@ -11,7 +11,6 @@ URL: http://netpbm.sourceforge.net/
 # svn checkout https://svn.code.sf.net/p/netpbm/code/trunk/test netpbm-%%{version}/test
 # and removing the .svn directories ( find -name "\.svn" -type d -print0 | xargs -0 rm -rf )
 Source0:         netpbm-%{version}.tar.xz
-Patch0:          netpbm-security-scripts.patch
 Patch1:          netpbm-security-code.patch
 Patch2:          netpbm-ppmfadeusage.patch
 Patch3:          netpbm-CVE-2017-2587.patch
@@ -24,14 +23,14 @@ Patch9:          netpbm-xwdfix.patch
 Patch10:         netpbm-multilib.patch
 Patch11:         netpbm-glibc.patch
 Patch12:         netpbm-docfix.patch
-Patch13:         netpbm-cmuwtopbm.patch
-Patch14:         netpbm-pamtojpeg2k.patch
-Patch15:         netpbm-manfix.patch
-Patch16:         netpbm-jasper.patch
-Patch17:         netpbm-libdir-so.patch
-Patch18:         netpbm-c99.patch
+Patch13:         netpbm-pamtojpeg2k.patch
+Patch14:         netpbm-manfix.patch
+Patch15:         netpbm-jasper.patch
+Patch16:         netpbm-libdir-so.patch
+Patch17:         netpbm-c99.patch
+Patch18:         netpbm-shlib-ldflags.patch
 
-BuildRequires: make
+BuildRequires:   make
 BuildRequires:   libjpeg-devel, libpng-devel, libtiff-devel, flex, gcc, jbigkit-devel
 BuildRequires:   libX11-devel, perl-generators, python3, jasper-devel, libxml2-devel
 BuildRequires:   perl(Config), perl(Cwd), perl(English), perl(Fcntl), perl(File::Basename)
@@ -120,19 +119,19 @@ TOP=`pwd`
 
 make \
 	CC="%{__cc}" \
-	LDFLAGS="$LD_FLAGS -L$TOP/pbm -L$TOP/pgm -L$TOP/pnm -L$TOP/ppm" \
+	LDFLAGS="$LDFLAGS -L$TOP/pbm -L$TOP/pgm -L$TOP/pnm -L$TOP/ppm" \
 	CFLAGS="$CFLAGS -fPIC -flax-vector-conversions -fno-strict-aliasing" \
 	CFLAGS_CONFIG="$CFLAGS" \
 	LADD="-lm" \
-	JPEGINC_DIR=%{_includedir} \
-	PNGINC_DIR=%{_includedir} \
-	TIFFINC_DIR=%{_includedir} \
-	JPEGLIB_DIR=%{_libdir} \
-	JBIGLIB=%{_libdir}/libjbig.so.2.1 \
-	PNGLIB_DIR=%{_libdir} \
-	TIFFLIB_DIR=%{_libdir} \
+	JPEGINC_DIR=%{_usr}/include \
+	PNGINC_DIR=%{_usr}/include \
+	TIFFINC_DIR=%{_usr}/include \
+	JPEGLIB_DIR=%{_usr}/%{_lib} \
+	JBIGLIB=%{_usr}/%{_lib}/libjbig.so.2.1 \
+	PNGLIB_DIR=%{_usr}/%{_lib} \
+	TIFFLIB_DIR=%{_usr}/%{_lib} \
 	LINUXSVGALIB="NONE" \
-	X11LIB=%{_libdir}/libX11.so \
+	X11LIB=%{_usr}/%{_lib}/libX11.so \
 	XML2LIBS="NONE"
 
 # prepare man files
@@ -150,12 +149,12 @@ done
 
 
 %install
-make package pkgdir=%{buildroot}/usr LINUXSVGALIB="NONE" XML2LIBS="NONE"
+make package pkgdir=%{buildroot}%{_prefix} LINUXSVGALIB="NONE" XML2LIBS="NONE"
 
 # Ugly hack to have libs in correct dir on 64bit archs.
 mkdir -p %{buildroot}%{_libdir}
-if [ "%{_libdir}" != "/usr/lib" ]; then
-  mv %{buildroot}/usr/lib/lib* %{buildroot}%{_libdir}
+if [ "%{_lib}" != "lib" ]; then
+  mv %{buildroot}%{_prefix}/lib/lib* %{buildroot}%{_libdir}
 fi
 
 cp -af lib/libnetpbm.a %{buildroot}%{_libdir}/libnetpbm.a
@@ -177,16 +176,16 @@ done
 rm -f %{buildroot}%{_mandir}/man5/extendedopacity.5
 
 mkdir -p %{buildroot}%{_datadir}/netpbm
-mv %{buildroot}/usr/misc/*.map %{buildroot}%{_datadir}/netpbm/
-mv %{buildroot}/usr/misc/rgb.txt %{buildroot}%{_datadir}/netpbm/
-rm -rf %{buildroot}/usr/README
-rm -rf %{buildroot}/usr/VERSION
-rm -rf %{buildroot}/usr/link
-rm -rf %{buildroot}/usr/misc
-rm -rf %{buildroot}/usr/man
-rm -rf %{buildroot}/usr/pkginfo
-rm -rf %{buildroot}/usr/config_template
-rm -rf %{buildroot}/usr/pkgconfig_template
+mv %{buildroot}%{_prefix}/misc/*.map %{buildroot}%{_datadir}/netpbm/
+mv %{buildroot}%{_prefix}/misc/rgb.txt %{buildroot}%{_datadir}/netpbm/
+rm -rf %{buildroot}%{_prefix}/README
+rm -rf %{buildroot}%{_prefix}/VERSION
+rm -rf %{buildroot}%{_prefix}/link
+rm -rf %{buildroot}%{_prefix}/misc
+rm -rf %{buildroot}%{_prefix}/man
+rm -rf %{buildroot}%{_prefix}/pkginfo
+rm -rf %{buildroot}%{_prefix}/config_template
+rm -rf %{buildroot}%{_prefix}/pkgconfig_template
 
 # Don't ship the static library
 rm -f %{buildroot}%{_libdir}/lib*.a
@@ -230,6 +229,54 @@ popd
 %doc userguide/*
 
 %changelog
+* Thu Jan 08 2026 Josef Ridky <jridky@redhat.com> - 11.13.00-1
+- New upstream release 11.13.00
+
+* Tue Oct 14 2025 Josef Ridky <jridky@redhat.com> - 11.12.00-1
+- New upstream release 11.12.00
+
+* Thu Jul 24 2025 Fedora Release Engineering <releng@fedoraproject.org> - 11.10.00-2
+- Rebuilt for https://fedoraproject.org/wiki/Fedora_43_Mass_Rebuild
+
+* Tue Apr 08 2025 Josef Ridky <jridky@redhat.com> - 11.10.00-1
+- New upstream release 11.10.00 (#2355869)
+
+* Thu Feb 06 2025 Josef Ridky <jridky@redhat.com> - 11.09.00-2
+- add LDFLAGS patch (RHEL-70899)
+
+* Tue Jan 28 2025 Josef Ridky <jridky@redhat.com> - 11.09.00-1
+- New upstream release 11.09.00 (#2218312)
+- Review and update license field
+
+* Fri Jan 17 2025 Fedora Release Engineering <releng@fedoraproject.org> - 11.02.00-10
+- Rebuilt for https://fedoraproject.org/wiki/Fedora_42_Mass_Rebuild
+
+* Fri Dec 13 2024 Lukáš Zaoral <lzaoral@redhat.com> - 11.02.00-9
+- build netpbm with correct LDFLAGS (RHEL-70899)
+
+* Mon Sep 02 2024 Miroslav Suchý <msuchy@redhat.com> - 11.02.00-8
+- convert license to SPDX
+
+* Thu Jul 18 2024 Fedora Release Engineering <releng@fedoraproject.org> - 11.02.00-7
+- Rebuilt for https://fedoraproject.org/wiki/Fedora_41_Mass_Rebuild
+
+* Thu Jan 25 2024 Fedora Release Engineering <releng@fedoraproject.org> - 11.02.00-6
+- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild
+
+* Sun Jan 21 2024 Florian Weimer <fweimer@redhat.com> - 11.02.00-5
+- GCC 14 compatibility fixes:
+  Drop netpbm-cmuwtopbm.patch to fix an out-of-bounds stack write (#2259450)
+  Stub out unused converter/other/jpeg2000/libjasper_compat.c (#2259448)
+
+* Sun Jan 21 2024 Fedora Release Engineering <releng@fedoraproject.org> - 11.02.00-4
+- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild
+
+* Tue Nov 28 2023 Orion Poplawski <orion@nwra.com> - 11.02.00-3
+- Rebuild for jasper 4.1
+
+* Thu Jul 20 2023 Fedora Release Engineering <releng@fedoraproject.org> - 11.02.00-2
+- Rebuilt for https://fedoraproject.org/wiki/Fedora_39_Mass_Rebuild
+
 * Mon Mar 27 2023 Josef Ridky <jridky@redhat.com> - 11.02.00-1
 - New upstream release 11.02.00 (#2157125)
 
diff --git a/sources b/sources
index 26ee665..4e39977 100644
--- a/sources
+++ b/sources
@@ -1 +1 @@
-SHA512 (netpbm-11.02.00.tar.xz) = 499cb8fb3897025b25842bd3408f91d08270ce912a9003e7ae4e6c16b7bb0a5c15372aa375ba464255bb4f005c213627b7e7c9749e37087cd0a895ba199899ae
+SHA512 (netpbm-11.13.00.tar.xz) = 0914061c7c8d638147afb76cbf23609b3ae43aca4120e4297fd5db6887d5381469d6944cdbdc1c66d26f54ec68d62355693c08b830dde823061e37c51480b678