tools/tiffcrop.c:6852: error: Integer Overflow L2
  ([0, 4294967294] + [0, 4294967294]):unsigned32 by call to `writeCroppedImage`.

tools/tiffcrop.c:6761:1: Parameter `(*out)->tif_dir.td_imagewidth`
6759.   } /* end extractImageSection */
6760. 
6761. static int 
      ^
6762. writeSelections(TIFF *in, TIFF **out, struct crop_mask *crop, 
6763.                 struct image_data *image, struct dump_opts *dump,

tools/tiffcrop.c:6852:16: Call
6850.            crop_buff = seg_buffs[i].buffer;
6851.            /* Write the current region to the current file */
6852.            if (writeCroppedImage(in, *out, image, dump,
                     ^
6853.                                  crop->regionlist[i].width, 
6854.                                  crop->regionlist[i].length, 

tools/tiffcrop.c:7604:1: Parameter `out->tif_dir.td_imagewidth`
  7602.  * then passed in as an argument.
  7603.  */
  7604. static int  
        ^
  7605. writeCroppedImage(TIFF *in, TIFF *out, struct image_data *image, 
  7606.                   struct dump_opts *dump, uint32 width, uint32 length, 

tools/tiffcrop.c:7848:11: Call
  7846.     if (config == PLANARCONFIG_CONTIG)
  7847.       {
  7848.       if (writeBufferToContigTiles (out, crop_buff, length, width, spp, dump))
                  ^
  7849.         TIFFError("","Unable to write contiguous tile data for page %d", pagenum);
  7850.       }

tools/tiffcrop.c:1194:1: Parameter `out->tif_dir.td_imagewidth`
    1192.  * to be written out as a tile.
    1193.  */
    1194. static int writeBufferToContigTiles (TIFF* out, uint8* buf, uint32 imagelength,
          ^
    1195. 				       uint32 imagewidth, tsample_t spp, 
    1196.                                        struct dump_opts* dump)

tools/tiffcrop.c:1252:11: Call
    1250.         }
    1251. 
    1252.       if (TIFFWriteTile(out, tilebuf, col, row, 0, 0) < 0)
                    ^
    1253.         {
    1254. 	TIFFError("writeBufferToContigTiles",

libtiff/tif_write.c:353:1: Parameter `tif->tif_dir.td_imagewidth`
      351.  * tile is selected by the (x,y,z,s) coordinates.
      352.  */
      353. tmsize_t
           ^
      354. TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s)
      355. {

libtiff/tif_write.c:356:7: Call
      354. TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s)
      355. {
      356. 	if (!TIFFCheckTile(tif, x, y, z, s))
                 ^
      357. 		return ((tmsize_t)(-1));
      358. 	/*

libtiff/tif_tile.c:74:1: Parameter `x`
        72.  * against the image bounds.
        73.  */
        74. int
            ^
        75. TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
        76. {

libtiff/tif_write.c:365:6: Call
      363. 	 */
      364. 	return (TIFFWriteEncodedTile(tif,
      365. 	    TIFFComputeTile(tif, x, y, z, s), buf, (tmsize_t)(-1)));
                ^
      366. }
      367. 

libtiff/tif_tile.c:37:1: Parameter `tif->tif_dir.td_imagewidth`
        35.  * Compute which tile an (x,y,z,s) value is in.
        36.  */
        37. uint32
            ^
        38. TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
        39. {

libtiff/tif_write.c:364:10: Call
      362. 	 *     after the output buffer is setup in TIFFWriteBufferSetup.
      363. 	 */
      364. 	return (TIFFWriteEncodedTile(tif,
                    ^
      365. 	    TIFFComputeTile(tif, x, y, z, s), buf, (tmsize_t)(-1)));
      366. }

libtiff/tif_write.c:380:1: Parameter `tif->tif_dir.td_imagewidth`
        378.  *     the image on each write (as TIFFWriteScanline does).
        379.  */
        380. tmsize_t
             ^
        381. TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
        382. {

libtiff/tif_write.c:388:7: Call
        386.         uint32 howmany32;
        387. 
        388. 	if (!WRITECHECKTILES(tif, module))
                   ^
        389. 		return ((tmsize_t)(-1));
        390. 	td = &tif->tif_dir;

libtiff/tif_write.c:566:1: Parameter `tif->tif_dir.td_imagewidth`
          564.  * that important information is not changed.
          565.  */
          566. int
               ^
          567. TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
          568. {

libtiff/tif_write.c:613:46: Call
          611. 		}
          612. 	}
          613. 	if (tif->tif_dir.td_stripoffset == NULL && !TIFFSetupStrips(tif)) {
                                                            ^
          614. 		tif->tif_dir.td_nstrips = 0;
          615. 		TIFFErrorExt(tif->tif_clientdata, module, "No space for %s arrays",

libtiff/tif_write.c:526:1: Parameter `tif->tif_dir.td_imagewidth`
            524.     (TIFFFieldSet(tif,f) && (tif)->tif_dir.td_imagelength == 0)
            525. 
            526. int
                 ^
            527. TIFFSetupStrips(TIFF* tif)
            528. {

libtiff/tif_write.c:534:29: Call
            532. 		td->td_stripsperimage =
            533. 		    isUnspecified(tif, FIELD_TILEDIMENSIONS) ?
            534. 			td->td_samplesperpixel : TIFFNumberOfTiles(tif);
                                             ^
            535. 	else
            536. 		td->td_stripsperimage =

libtiff/tif_tile.c:114:1: <LHS trace>
112.  * Compute how many tiles are in an image.
113.  */
114. uint32
     ^
115. TIFFNumberOfTiles(TIFF* tif)
116. {

libtiff/tif_tile.c:114:1: Parameter `tif->tif_dir.td_imagewidth`
              112.  * Compute how many tiles are in an image.
              113.  */
              114. uint32
                   ^
              115. TIFFNumberOfTiles(TIFF* tif)
              116. {

libtiff/tif_tile.c:114:1: <RHS trace>
112.  * Compute how many tiles are in an image.
113.  */
114. uint32
     ^
115. TIFFNumberOfTiles(TIFF* tif)
116. {

libtiff/tif_tile.c:114:1: Parameter `tif->tif_dir.td_imagewidth`
              112.  * Compute how many tiles are in an image.
              113.  */
              114. uint32
                   ^
              115. TIFFNumberOfTiles(TIFF* tif)
              116. {

libtiff/tif_tile.c:130:48: Binary operation: ([0, 4294967294] + [0, 4294967294]):unsigned32 by call to `writeCroppedImage` 
              128. 		dz = td->td_imagedepth;
              129. 	ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
              130. 	    _TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
                                                                  ^
              131. 	    TIFFhowmany_32(td->td_imagelength, dy),
              132. 	    "TIFFNumberOfTiles"),
