2008-01-13 Thomas Koenig <tkoenig@gcc.gnu.org>

	PR libfortran/34746
	* m4/iforeach.m4 (name`'rtype_qual`_'atype_code):  Use %ld
	in printf format for all bounds checking; cast all
	integer-like arguments to runtime_error() to long int.
	(`m'name`'rtype_qual`_'atype_code):  Likewise.
	(`s'name`'rtype_qual`_'atype_code):  Likewise.
	* m4/ifunction.m4 (name`'rtype_qual`_'atype_code):  Likewise.
	(`m'name`'rtype_qual`_'atype_code):  Likewise.
	(`s'name`'rtype_qual`_'atype_code):  Likewise.
	* generated/all_l16.c: Regenerated.
	* generated/all_l4.c: Regenerated.
	* generated/all_l8.c: Regenerated.
	* generated/any_l16.c: Regenerated.
	* generated/any_l4.c: Regenerated.
	* generated/any_l8.c: Regenerated.
	* generated/count_16_l16.c: Regenerated.
	* generated/count_16_l4.c: Regenerated.
	* generated/count_16_l8.c: Regenerated.
	* generated/count_4_l16.c: Regenerated.
	* generated/count_4_l4.c: Regenerated.
	* generated/count_4_l8.c: Regenerated.
	* generated/count_8_l16.c: Regenerated.
	* generated/count_8_l4.c: Regenerated.
	* generated/count_8_l8.c: Regenerated.
	* generated/maxloc0_16_i1.c: Regenerated.
	* generated/maxloc0_16_i16.c: Regenerated.
	* generated/maxloc0_16_i2.c: Regenerated.
	* generated/maxloc0_16_i4.c: Regenerated.
	* generated/maxloc0_16_i8.c: Regenerated.
	* generated/maxloc0_16_r10.c: Regenerated.
	* generated/maxloc0_16_r16.c: Regenerated.
	* generated/maxloc0_16_r4.c: Regenerated.
	* generated/maxloc0_16_r8.c: Regenerated.
	* generated/maxloc0_4_i1.c: Regenerated.
	* generated/maxloc0_4_i16.c: Regenerated.
	* generated/maxloc0_4_i2.c: Regenerated.
	* generated/maxloc0_4_i4.c: Regenerated.
	* generated/maxloc0_4_i8.c: Regenerated.
	* generated/maxloc0_4_r10.c: Regenerated.
	* generated/maxloc0_4_r16.c: Regenerated.
	* generated/maxloc0_4_r4.c: Regenerated.
	* generated/maxloc0_4_r8.c: Regenerated.
	* generated/maxloc0_8_i1.c: Regenerated.
	* generated/maxloc0_8_i16.c: Regenerated.
	* generated/maxloc0_8_i2.c: Regenerated.
	* generated/maxloc0_8_i4.c: Regenerated.
	* generated/maxloc0_8_i8.c: Regenerated.
	* generated/maxloc0_8_r10.c: Regenerated.
	* generated/maxloc0_8_r16.c: Regenerated.
	* generated/maxloc0_8_r4.c: Regenerated.
	* generated/maxloc0_8_r8.c: Regenerated.
	* generated/maxloc1_16_i1.c: Regenerated.
	* generated/maxloc1_16_i16.c: Regenerated.
	* generated/maxloc1_16_i2.c: Regenerated.
	* generated/maxloc1_16_i4.c: Regenerated.
	* generated/maxloc1_16_i8.c: Regenerated.
	* generated/maxloc1_16_r10.c: Regenerated.
	* generated/maxloc1_16_r16.c: Regenerated.
	* generated/maxloc1_16_r4.c: Regenerated.
	* generated/maxloc1_16_r8.c: Regenerated.
	* generated/maxloc1_4_i1.c: Regenerated.
	* generated/maxloc1_4_i16.c: Regenerated.
	* generated/maxloc1_4_i2.c: Regenerated.
	* generated/maxloc1_4_i4.c: Regenerated.
	* generated/maxloc1_4_i8.c: Regenerated.
	* generated/maxloc1_4_r10.c: Regenerated.
	* generated/maxloc1_4_r16.c: Regenerated.
	* generated/maxloc1_4_r4.c: Regenerated.
	* generated/maxloc1_4_r8.c: Regenerated.
	* generated/maxloc1_8_i1.c: Regenerated.
	* generated/maxloc1_8_i16.c: Regenerated.
	* generated/maxloc1_8_i2.c: Regenerated.
	* generated/maxloc1_8_i4.c: Regenerated.
	* generated/maxloc1_8_i8.c: Regenerated.
	* generated/maxloc1_8_r10.c: Regenerated.
	* generated/maxloc1_8_r16.c: Regenerated.
	* generated/maxloc1_8_r4.c: Regenerated.
	* generated/maxloc1_8_r8.c: Regenerated.
	* generated/maxval_i1.c: Regenerated.
	* generated/maxval_i16.c: Regenerated.
	* generated/maxval_i2.c: Regenerated.
	* generated/maxval_i4.c: Regenerated.
	* generated/maxval_i8.c: Regenerated.
	* generated/maxval_r10.c: Regenerated.
	* generated/maxval_r16.c: Regenerated.
	* generated/maxval_r4.c: Regenerated.
	* generated/maxval_r8.c: Regenerated.
	* generated/minloc0_16_i1.c: Regenerated.
	* generated/minloc0_16_i16.c: Regenerated.
	* generated/minloc0_16_i2.c: Regenerated.
	* generated/minloc0_16_i4.c: Regenerated.
	* generated/minloc0_16_i8.c: Regenerated.
	* generated/minloc0_16_r10.c: Regenerated.
	* generated/minloc0_16_r16.c: Regenerated.
	* generated/minloc0_16_r4.c: Regenerated.
	* generated/minloc0_16_r8.c: Regenerated.
	* generated/minloc0_4_i1.c: Regenerated.
	* generated/minloc0_4_i16.c: Regenerated.
	* generated/minloc0_4_i2.c: Regenerated.
	* generated/minloc0_4_i4.c: Regenerated.
	* generated/minloc0_4_i8.c: Regenerated.
	* generated/minloc0_4_r10.c: Regenerated.
	* generated/minloc0_4_r16.c: Regenerated.
	* generated/minloc0_4_r4.c: Regenerated.
	* generated/minloc0_4_r8.c: Regenerated.
	* generated/minloc0_8_i1.c: Regenerated.
	* generated/minloc0_8_i16.c: Regenerated.
	* generated/minloc0_8_i2.c: Regenerated.
	* generated/minloc0_8_i4.c: Regenerated.
	* generated/minloc0_8_i8.c: Regenerated.
	* generated/minloc0_8_r10.c: Regenerated.
	* generated/minloc0_8_r16.c: Regenerated.
	* generated/minloc0_8_r4.c: Regenerated.
	* generated/minloc0_8_r8.c: Regenerated.
	* generated/minloc1_16_i1.c: Regenerated.
	* generated/minloc1_16_i16.c: Regenerated.
	* generated/minloc1_16_i2.c: Regenerated.
	* generated/minloc1_16_i4.c: Regenerated.
	* generated/minloc1_16_i8.c: Regenerated.
	* generated/minloc1_16_r10.c: Regenerated.
	* generated/minloc1_16_r16.c: Regenerated.
	* generated/minloc1_16_r4.c: Regenerated.
	* generated/minloc1_16_r8.c: Regenerated.
	* generated/minloc1_4_i1.c: Regenerated.
	* generated/minloc1_4_i16.c: Regenerated.
	* generated/minloc1_4_i2.c: Regenerated.
	* generated/minloc1_4_i4.c: Regenerated.
	* generated/minloc1_4_i8.c: Regenerated.
	* generated/minloc1_4_r10.c: Regenerated.
	* generated/minloc1_4_r16.c: Regenerated.
	* generated/minloc1_4_r4.c: Regenerated.
	* generated/minloc1_4_r8.c: Regenerated.
	* generated/minloc1_8_i1.c: Regenerated.
	* generated/minloc1_8_i16.c: Regenerated.
	* generated/minloc1_8_i2.c: Regenerated.
	* generated/minloc1_8_i4.c: Regenerated.
	* generated/minloc1_8_i8.c: Regenerated.
	* generated/minloc1_8_r10.c: Regenerated.
	* generated/minloc1_8_r16.c: Regenerated.
	* generated/minloc1_8_r4.c: Regenerated.
	* generated/minloc1_8_r8.c: Regenerated.
	* generated/minval_i1.c: Regenerated.
	* generated/minval_i16.c: Regenerated.
	* generated/minval_i2.c: Regenerated.
	* generated/minval_i4.c: Regenerated.
	* generated/minval_i8.c: Regenerated.
	* generated/minval_r10.c: Regenerated.
	* generated/minval_r16.c: Regenerated.
	* generated/minval_r4.c: Regenerated.
	* generated/minval_r8.c: Regenerated.
	* generated/product_c10.c: Regenerated.
	* generated/product_c16.c: Regenerated.
	* generated/product_c4.c: Regenerated.
	* generated/product_c8.c: Regenerated.
	* generated/product_i1.c: Regenerated.
	* generated/product_i16.c: Regenerated.
	* generated/product_i2.c: Regenerated.
	* generated/product_i4.c: Regenerated.
	* generated/product_i8.c: Regenerated.
	* generated/product_r10.c: Regenerated.
	* generated/product_r16.c: Regenerated.
	* generated/product_r4.c: Regenerated.
	* generated/product_r8.c: Regenerated.
	* generated/sum_c10.c: Regenerated.
	* generated/sum_c16.c: Regenerated.
	* generated/sum_c4.c: Regenerated.
	* generated/sum_c8.c: Regenerated.
	* generated/sum_i1.c: Regenerated.
	* generated/sum_i16.c: Regenerated.
	* generated/sum_i2.c: Regenerated.
	* generated/sum_i4.c: Regenerated.
	* generated/sum_i8.c: Regenerated.
	* generated/sum_r10.c: Regenerated.
	* generated/sum_r16.c: Regenerated.
	* generated/sum_r4.c: Regenerated.
	* generated/sum_r8.c: Regenerated.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@131514 138bc75d-0d04-0410-961f-82ee72b054a4

170 files changed, 1849 insertions, 1501 deletions

diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog
index 34b730795e1..16ef713c4b5 100644
--- a/libgfortran/ChangeLog
+++ b/libgfortran/ChangeLog
@@ -1,3 +1,182 @@
+2008-01-13  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR libfortran/34746
+	* m4/iforeach.m4 (name`'rtype_qual`_'atype_code):  Use %ld
+	in printf format for all bounds checking; cast all
+	integer-like arguments to runtime_error() to long int.
+	(`m'name`'rtype_qual`_'atype_code):  Likewise.
+	(`s'name`'rtype_qual`_'atype_code):  Likewise.
+	* m4/ifunction.m4 (name`'rtype_qual`_'atype_code):  Likewise.
+	(`m'name`'rtype_qual`_'atype_code):  Likewise.
+	(`s'name`'rtype_qual`_'atype_code):  Likewise.
+	* generated/all_l16.c: Regenerated.
+	* generated/all_l4.c: Regenerated.
+	* generated/all_l8.c: Regenerated.
+	* generated/any_l16.c: Regenerated.
+	* generated/any_l4.c: Regenerated.
+	* generated/any_l8.c: Regenerated.
+	* generated/count_16_l16.c: Regenerated.
+	* generated/count_16_l4.c: Regenerated.
+	* generated/count_16_l8.c: Regenerated.
+	* generated/count_4_l16.c: Regenerated.
+	* generated/count_4_l4.c: Regenerated.
+	* generated/count_4_l8.c: Regenerated.
+	* generated/count_8_l16.c: Regenerated.
+	* generated/count_8_l4.c: Regenerated.
+	* generated/count_8_l8.c: Regenerated.
+	* generated/maxloc0_16_i1.c: Regenerated.
+	* generated/maxloc0_16_i16.c: Regenerated.
+	* generated/maxloc0_16_i2.c: Regenerated.
+	* generated/maxloc0_16_i4.c: Regenerated.
+	* generated/maxloc0_16_i8.c: Regenerated.
+	* generated/maxloc0_16_r10.c: Regenerated.
+	* generated/maxloc0_16_r16.c: Regenerated.
+	* generated/maxloc0_16_r4.c: Regenerated.
+	* generated/maxloc0_16_r8.c: Regenerated.
+	* generated/maxloc0_4_i1.c: Regenerated.
+	* generated/maxloc0_4_i16.c: Regenerated.
+	* generated/maxloc0_4_i2.c: Regenerated.
+	* generated/maxloc0_4_i4.c: Regenerated.
+	* generated/maxloc0_4_i8.c: Regenerated.
+	* generated/maxloc0_4_r10.c: Regenerated.
+	* generated/maxloc0_4_r16.c: Regenerated.
+	* generated/maxloc0_4_r4.c: Regenerated.
+	* generated/maxloc0_4_r8.c: Regenerated.
+	* generated/maxloc0_8_i1.c: Regenerated.
+	* generated/maxloc0_8_i16.c: Regenerated.
+	* generated/maxloc0_8_i2.c: Regenerated.
+	* generated/maxloc0_8_i4.c: Regenerated.
+	* generated/maxloc0_8_i8.c: Regenerated.
+	* generated/maxloc0_8_r10.c: Regenerated.
+	* generated/maxloc0_8_r16.c: Regenerated.
+	* generated/maxloc0_8_r4.c: Regenerated.
+	* generated/maxloc0_8_r8.c: Regenerated.
+	* generated/maxloc1_16_i1.c: Regenerated.
+	* generated/maxloc1_16_i16.c: Regenerated.
+	* generated/maxloc1_16_i2.c: Regenerated.
+	* generated/maxloc1_16_i4.c: Regenerated.
+	* generated/maxloc1_16_i8.c: Regenerated.
+	* generated/maxloc1_16_r10.c: Regenerated.
+	* generated/maxloc1_16_r16.c: Regenerated.
+	* generated/maxloc1_16_r4.c: Regenerated.
+	* generated/maxloc1_16_r8.c: Regenerated.
+	* generated/maxloc1_4_i1.c: Regenerated.
+	* generated/maxloc1_4_i16.c: Regenerated.
+	* generated/maxloc1_4_i2.c: Regenerated.
+	* generated/maxloc1_4_i4.c: Regenerated.
+	* generated/maxloc1_4_i8.c: Regenerated.
+	* generated/maxloc1_4_r10.c: Regenerated.
+	* generated/maxloc1_4_r16.c: Regenerated.
+	* generated/maxloc1_4_r4.c: Regenerated.
+	* generated/maxloc1_4_r8.c: Regenerated.
+	* generated/maxloc1_8_i1.c: Regenerated.
+	* generated/maxloc1_8_i16.c: Regenerated.
+	* generated/maxloc1_8_i2.c: Regenerated.
+	* generated/maxloc1_8_i4.c: Regenerated.
+	* generated/maxloc1_8_i8.c: Regenerated.
+	* generated/maxloc1_8_r10.c: Regenerated.
+	* generated/maxloc1_8_r16.c: Regenerated.
+	* generated/maxloc1_8_r4.c: Regenerated.
+	* generated/maxloc1_8_r8.c: Regenerated.
+	* generated/maxval_i1.c: Regenerated.
+	* generated/maxval_i16.c: Regenerated.
+	* generated/maxval_i2.c: Regenerated.
+	* generated/maxval_i4.c: Regenerated.
+	* generated/maxval_i8.c: Regenerated.
+	* generated/maxval_r10.c: Regenerated.
+	* generated/maxval_r16.c: Regenerated.
+	* generated/maxval_r4.c: Regenerated.
+	* generated/maxval_r8.c: Regenerated.
+	* generated/minloc0_16_i1.c: Regenerated.
+	* generated/minloc0_16_i16.c: Regenerated.
+	* generated/minloc0_16_i2.c: Regenerated.
+	* generated/minloc0_16_i4.c: Regenerated.
+	* generated/minloc0_16_i8.c: Regenerated.
+	* generated/minloc0_16_r10.c: Regenerated.
+	* generated/minloc0_16_r16.c: Regenerated.
+	* generated/minloc0_16_r4.c: Regenerated.
+	* generated/minloc0_16_r8.c: Regenerated.
+	* generated/minloc0_4_i1.c: Regenerated.
+	* generated/minloc0_4_i16.c: Regenerated.
+	* generated/minloc0_4_i2.c: Regenerated.
+	* generated/minloc0_4_i4.c: Regenerated.
+	* generated/minloc0_4_i8.c: Regenerated.
+	* generated/minloc0_4_r10.c: Regenerated.
+	* generated/minloc0_4_r16.c: Regenerated.
+	* generated/minloc0_4_r4.c: Regenerated.
+	* generated/minloc0_4_r8.c: Regenerated.
+	* generated/minloc0_8_i1.c: Regenerated.
+	* generated/minloc0_8_i16.c: Regenerated.
+	* generated/minloc0_8_i2.c: Regenerated.
+	* generated/minloc0_8_i4.c: Regenerated.
+	* generated/minloc0_8_i8.c: Regenerated.
+	* generated/minloc0_8_r10.c: Regenerated.
+	* generated/minloc0_8_r16.c: Regenerated.
+	* generated/minloc0_8_r4.c: Regenerated.
+	* generated/minloc0_8_r8.c: Regenerated.
+	* generated/minloc1_16_i1.c: Regenerated.
+	* generated/minloc1_16_i16.c: Regenerated.
+	* generated/minloc1_16_i2.c: Regenerated.
+	* generated/minloc1_16_i4.c: Regenerated.
+	* generated/minloc1_16_i8.c: Regenerated.
+	* generated/minloc1_16_r10.c: Regenerated.
+	* generated/minloc1_16_r16.c: Regenerated.
+	* generated/minloc1_16_r4.c: Regenerated.
+	* generated/minloc1_16_r8.c: Regenerated.
+	* generated/minloc1_4_i1.c: Regenerated.
+	* generated/minloc1_4_i16.c: Regenerated.
+	* generated/minloc1_4_i2.c: Regenerated.
+	* generated/minloc1_4_i4.c: Regenerated.
+	* generated/minloc1_4_i8.c: Regenerated.
+	* generated/minloc1_4_r10.c: Regenerated.
+	* generated/minloc1_4_r16.c: Regenerated.
+	* generated/minloc1_4_r4.c: Regenerated.
+	* generated/minloc1_4_r8.c: Regenerated.
+	* generated/minloc1_8_i1.c: Regenerated.
+	* generated/minloc1_8_i16.c: Regenerated.
+	* generated/minloc1_8_i2.c: Regenerated.
+	* generated/minloc1_8_i4.c: Regenerated.
+	* generated/minloc1_8_i8.c: Regenerated.
+	* generated/minloc1_8_r10.c: Regenerated.
+	* generated/minloc1_8_r16.c: Regenerated.
+	* generated/minloc1_8_r4.c: Regenerated.
+	* generated/minloc1_8_r8.c: Regenerated.
+	* generated/minval_i1.c: Regenerated.
+	* generated/minval_i16.c: Regenerated.
+	* generated/minval_i2.c: Regenerated.
+	* generated/minval_i4.c: Regenerated.
+	* generated/minval_i8.c: Regenerated.
+	* generated/minval_r10.c: Regenerated.
+	* generated/minval_r16.c: Regenerated.
+	* generated/minval_r4.c: Regenerated.
+	* generated/minval_r8.c: Regenerated.
+	* generated/product_c10.c: Regenerated.
+	* generated/product_c16.c: Regenerated.
+	* generated/product_c4.c: Regenerated.
+	* generated/product_c8.c: Regenerated.
+	* generated/product_i1.c: Regenerated.
+	* generated/product_i16.c: Regenerated.
+	* generated/product_i2.c: Regenerated.
+	* generated/product_i4.c: Regenerated.
+	* generated/product_i8.c: Regenerated.
+	* generated/product_r10.c: Regenerated.
+	* generated/product_r16.c: Regenerated.
+	* generated/product_r4.c: Regenerated.
+	* generated/product_r8.c: Regenerated.
+	* generated/sum_c10.c: Regenerated.
+	* generated/sum_c16.c: Regenerated.
+	* generated/sum_c4.c: Regenerated.
+	* generated/sum_c8.c: Regenerated.
+	* generated/sum_i1.c: Regenerated.
+	* generated/sum_i16.c: Regenerated.
+	* generated/sum_i2.c: Regenerated.
+	* generated/sum_i4.c: Regenerated.
+	* generated/sum_i8.c: Regenerated.
+	* generated/sum_r10.c: Regenerated.
+	* generated/sum_r16.c: Regenerated.
+	* generated/sum_r4.c: Regenerated.
+	* generated/sum_r8.c: Regenerated.
+
 2008-01-11  Thomas Koenig  <tkoenig@gcc.gnu.org>
 
 	PR libfortran/34670
diff --git a/libgfortran/generated/all_l16.c b/libgfortran/generated/all_l16.c
index 2cc81ce423a..9c53707ae76 100644
--- a/libgfortran/generated/all_l16.c
+++ b/libgfortran/generated/all_l16.c
@@ -116,8 +116,9 @@ all_l16 (gfc_array_l16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " ALL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " ALL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ all_l16 (gfc_array_l16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " ALL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " ALL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/all_l4.c b/libgfortran/generated/all_l4.c
index 12f9efb2b91..6eb798619b6 100644
--- a/libgfortran/generated/all_l4.c
+++ b/libgfortran/generated/all_l4.c
@@ -116,8 +116,9 @@ all_l4 (gfc_array_l4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " ALL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " ALL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ all_l4 (gfc_array_l4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " ALL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " ALL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/all_l8.c b/libgfortran/generated/all_l8.c
index c9fa80935ae..7b98652bce5 100644
--- a/libgfortran/generated/all_l8.c
+++ b/libgfortran/generated/all_l8.c
@@ -116,8 +116,9 @@ all_l8 (gfc_array_l8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " ALL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " ALL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ all_l8 (gfc_array_l8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " ALL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " ALL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/any_l16.c b/libgfortran/generated/any_l16.c
index 1ba59edbadd..bffd620f02b 100644
--- a/libgfortran/generated/any_l16.c
+++ b/libgfortran/generated/any_l16.c
@@ -116,8 +116,9 @@ any_l16 (gfc_array_l16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " ANY intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " ANY intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ any_l16 (gfc_array_l16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " ANY intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " ANY intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/any_l4.c b/libgfortran/generated/any_l4.c
index 83116ebe9ca..f86445e69e1 100644
--- a/libgfortran/generated/any_l4.c
+++ b/libgfortran/generated/any_l4.c
@@ -116,8 +116,9 @@ any_l4 (gfc_array_l4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " ANY intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " ANY intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ any_l4 (gfc_array_l4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " ANY intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " ANY intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/any_l8.c b/libgfortran/generated/any_l8.c
index a85e6e89ca0..f155abbed36 100644
--- a/libgfortran/generated/any_l8.c
+++ b/libgfortran/generated/any_l8.c
@@ -116,8 +116,9 @@ any_l8 (gfc_array_l8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " ANY intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " ANY intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ any_l8 (gfc_array_l8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " ANY intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " ANY intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/count_16_l16.c b/libgfortran/generated/count_16_l16.c
index 351eb8a1e65..4f3418bd73a 100644
--- a/libgfortran/generated/count_16_l16.c
+++ b/libgfortran/generated/count_16_l16.c
@@ -116,8 +116,9 @@ count_16_l16 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " COUNT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " COUNT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ count_16_l16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " COUNT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " COUNT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/count_16_l4.c b/libgfortran/generated/count_16_l4.c
index 9f849d8b725..9b853699b9d 100644
--- a/libgfortran/generated/count_16_l4.c
+++ b/libgfortran/generated/count_16_l4.c
@@ -116,8 +116,9 @@ count_16_l4 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " COUNT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " COUNT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ count_16_l4 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " COUNT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " COUNT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/count_16_l8.c b/libgfortran/generated/count_16_l8.c
index 90659da0a17..7a6a31adf0c 100644
--- a/libgfortran/generated/count_16_l8.c
+++ b/libgfortran/generated/count_16_l8.c
@@ -116,8 +116,9 @@ count_16_l8 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " COUNT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " COUNT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ count_16_l8 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " COUNT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " COUNT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/count_4_l16.c b/libgfortran/generated/count_4_l16.c
index c3b3daad85a..5dee5468c64 100644
--- a/libgfortran/generated/count_4_l16.c
+++ b/libgfortran/generated/count_4_l16.c
@@ -116,8 +116,9 @@ count_4_l16 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " COUNT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " COUNT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ count_4_l16 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " COUNT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " COUNT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/count_4_l4.c b/libgfortran/generated/count_4_l4.c
index 3bfcf179c75..04493b2f4b4 100644
--- a/libgfortran/generated/count_4_l4.c
+++ b/libgfortran/generated/count_4_l4.c
@@ -116,8 +116,9 @@ count_4_l4 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " COUNT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " COUNT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ count_4_l4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " COUNT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " COUNT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/count_4_l8.c b/libgfortran/generated/count_4_l8.c
index 7debda799bb..0e2f9bbb543 100644
--- a/libgfortran/generated/count_4_l8.c
+++ b/libgfortran/generated/count_4_l8.c
@@ -116,8 +116,9 @@ count_4_l8 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " COUNT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " COUNT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ count_4_l8 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " COUNT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " COUNT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/count_8_l16.c b/libgfortran/generated/count_8_l16.c
index 815b79ab65c..b0d11164fc5 100644
--- a/libgfortran/generated/count_8_l16.c
+++ b/libgfortran/generated/count_8_l16.c
@@ -116,8 +116,9 @@ count_8_l16 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " COUNT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " COUNT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ count_8_l16 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " COUNT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " COUNT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/count_8_l4.c b/libgfortran/generated/count_8_l4.c
index 84401ded1e1..e6a386e8a8d 100644
--- a/libgfortran/generated/count_8_l4.c
+++ b/libgfortran/generated/count_8_l4.c
@@ -116,8 +116,9 @@ count_8_l4 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " COUNT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " COUNT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ count_8_l4 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " COUNT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " COUNT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/count_8_l8.c b/libgfortran/generated/count_8_l8.c
index fd26280a550..2a1b2a570de 100644
--- a/libgfortran/generated/count_8_l8.c
+++ b/libgfortran/generated/count_8_l8.c
@@ -116,8 +116,9 @@ count_8_l8 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " COUNT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " COUNT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ count_8_l8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " COUNT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " COUNT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
diff --git a/libgfortran/generated/maxloc0_16_i1.c b/libgfortran/generated/maxloc0_16_i1.c
index 3cd6554a346..7fc44432fa4 100644
--- a/libgfortran/generated/maxloc0_16_i1.c
+++ b/libgfortran/generated/maxloc0_16_i1.c
@@ -77,13 +77,13 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_16_i16.c b/libgfortran/generated/maxloc0_16_i16.c
index 9bfec043013..29eb3ccecf1 100644
--- a/libgfortran/generated/maxloc0_16_i16.c
+++ b/libgfortran/generated/maxloc0_16_i16.c
@@ -77,13 +77,13 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_16_i2.c b/libgfortran/generated/maxloc0_16_i2.c
index b57e78f9274..30b693c1068 100644
--- a/libgfortran/generated/maxloc0_16_i2.c
+++ b/libgfortran/generated/maxloc0_16_i2.c
@@ -77,13 +77,13 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_16_i4.c b/libgfortran/generated/maxloc0_16_i4.c
index 2e123b6d295..03f2794f30b 100644
--- a/libgfortran/generated/maxloc0_16_i4.c
+++ b/libgfortran/generated/maxloc0_16_i4.c
@@ -77,13 +77,13 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_16_i8.c b/libgfortran/generated/maxloc0_16_i8.c
index cd141a69222..be18af39ce8 100644
--- a/libgfortran/generated/maxloc0_16_i8.c
+++ b/libgfortran/generated/maxloc0_16_i8.c
@@ -77,13 +77,13 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_16_r10.c b/libgfortran/generated/maxloc0_16_r10.c
index 8426d3af81e..48ba77e8732 100644
--- a/libgfortran/generated/maxloc0_16_r10.c
+++ b/libgfortran/generated/maxloc0_16_r10.c
@@ -77,13 +77,13 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_16_r16.c b/libgfortran/generated/maxloc0_16_r16.c
index 3244452c601..9d2ce087015 100644
--- a/libgfortran/generated/maxloc0_16_r16.c
+++ b/libgfortran/generated/maxloc0_16_r16.c
@@ -77,13 +77,13 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_16_r4.c b/libgfortran/generated/maxloc0_16_r4.c
index 8057063339c..e908dadcdd0 100644
--- a/libgfortran/generated/maxloc0_16_r4.c
+++ b/libgfortran/generated/maxloc0_16_r4.c
@@ -77,13 +77,13 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_16_r8.c b/libgfortran/generated/maxloc0_16_r8.c
index 6c12815a0a1..cb01745a44c 100644
--- a/libgfortran/generated/maxloc0_16_r8.c
+++ b/libgfortran/generated/maxloc0_16_r8.c
@@ -77,13 +77,13 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_4_i1.c b/libgfortran/generated/maxloc0_4_i1.c
index 42c865a6e29..21ab578c402 100644
--- a/libgfortran/generated/maxloc0_4_i1.c
+++ b/libgfortran/generated/maxloc0_4_i1.c
@@ -77,13 +77,13 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_4_i16.c b/libgfortran/generated/maxloc0_4_i16.c
index 938ceba6974..6803420884c 100644
--- a/libgfortran/generated/maxloc0_4_i16.c
+++ b/libgfortran/generated/maxloc0_4_i16.c
@@ -77,13 +77,13 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_4_i2.c b/libgfortran/generated/maxloc0_4_i2.c
index 809d93821dc..27cccae9784 100644
--- a/libgfortran/generated/maxloc0_4_i2.c
+++ b/libgfortran/generated/maxloc0_4_i2.c
@@ -77,13 +77,13 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_4_i4.c b/libgfortran/generated/maxloc0_4_i4.c
index 5108cbe1366..650da03a1ed 100644
--- a/libgfortran/generated/maxloc0_4_i4.c
+++ b/libgfortran/generated/maxloc0_4_i4.c
@@ -77,13 +77,13 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_4_i8.c b/libgfortran/generated/maxloc0_4_i8.c
index 987b424d7e1..48e1d3e5215 100644
--- a/libgfortran/generated/maxloc0_4_i8.c
+++ b/libgfortran/generated/maxloc0_4_i8.c
@@ -77,13 +77,13 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_4_r10.c b/libgfortran/generated/maxloc0_4_r10.c
index b3101bd6ac8..05e31659238 100644
--- a/libgfortran/generated/maxloc0_4_r10.c
+++ b/libgfortran/generated/maxloc0_4_r10.c
@@ -77,13 +77,13 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_4_r16.c b/libgfortran/generated/maxloc0_4_r16.c
index 9b1e5274a3f..38cf3527282 100644
--- a/libgfortran/generated/maxloc0_4_r16.c
+++ b/libgfortran/generated/maxloc0_4_r16.c
@@ -77,13 +77,13 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_4_r4.c b/libgfortran/generated/maxloc0_4_r4.c
index bf4692c26f0..5ab9429028e 100644
--- a/libgfortran/generated/maxloc0_4_r4.c
+++ b/libgfortran/generated/maxloc0_4_r4.c
@@ -77,13 +77,13 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_4_r8.c b/libgfortran/generated/maxloc0_4_r8.c
index 774a6734c2d..2658e4a5b9a 100644
--- a/libgfortran/generated/maxloc0_4_r8.c
+++ b/libgfortran/generated/maxloc0_4_r8.c
@@ -77,13 +77,13 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_8_i1.c b/libgfortran/generated/maxloc0_8_i1.c
index 38890b70dcf..ce71eb1ebbd 100644
--- a/libgfortran/generated/maxloc0_8_i1.c
+++ b/libgfortran/generated/maxloc0_8_i1.c
@@ -77,13 +77,13 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_8_i16.c b/libgfortran/generated/maxloc0_8_i16.c
index be99a8ca0b1..e808a91cf59 100644
--- a/libgfortran/generated/maxloc0_8_i16.c
+++ b/libgfortran/generated/maxloc0_8_i16.c
@@ -77,13 +77,13 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_8_i2.c b/libgfortran/generated/maxloc0_8_i2.c
index 02a5f645e8e..8bc1961ea3a 100644
--- a/libgfortran/generated/maxloc0_8_i2.c
+++ b/libgfortran/generated/maxloc0_8_i2.c
@@ -77,13 +77,13 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_8_i4.c b/libgfortran/generated/maxloc0_8_i4.c
index dca0b768861..8b6d2128a5d 100644
--- a/libgfortran/generated/maxloc0_8_i4.c
+++ b/libgfortran/generated/maxloc0_8_i4.c
@@ -77,13 +77,13 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_8_i8.c b/libgfortran/generated/maxloc0_8_i8.c
index d11ba2677f2..121827eabb3 100644
--- a/libgfortran/generated/maxloc0_8_i8.c
+++ b/libgfortran/generated/maxloc0_8_i8.c
@@ -77,13 +77,13 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_8_r10.c b/libgfortran/generated/maxloc0_8_r10.c
index 898f1f57673..8fb4b13eb69 100644
--- a/libgfortran/generated/maxloc0_8_r10.c
+++ b/libgfortran/generated/maxloc0_8_r10.c
@@ -77,13 +77,13 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_8_r16.c b/libgfortran/generated/maxloc0_8_r16.c
index 6dec78a49f9..7a5a4f354af 100644
--- a/libgfortran/generated/maxloc0_8_r16.c
+++ b/libgfortran/generated/maxloc0_8_r16.c
@@ -77,13 +77,13 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_8_r4.c b/libgfortran/generated/maxloc0_8_r4.c
index 345dbe1a9d1..8e02dcb7718 100644
--- a/libgfortran/generated/maxloc0_8_r4.c
+++ b/libgfortran/generated/maxloc0_8_r4.c
@@ -77,13 +77,13 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc0_8_r8.c b/libgfortran/generated/maxloc0_8_r8.c
index bf7020e1a10..c539df0596d 100644
--- a/libgfortran/generated/maxloc0_8_r8.c
+++ b/libgfortran/generated/maxloc0_8_r8.c
@@ -77,13 +77,13 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MAXLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MAXLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c
index 477eb704a86..47e67239322 100644
--- a/libgfortran/generated/maxloc1_16_i1.c
+++ b/libgfortran/generated/maxloc1_16_i1.c
@@ -117,8 +117,9 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c
index e4a2c1b361b..2c8a06cb675 100644
--- a/libgfortran/generated/maxloc1_16_i16.c
+++ b/libgfortran/generated/maxloc1_16_i16.c
@@ -117,8 +117,9 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c
index f5d7b587aed..d7b1ca57eed 100644
--- a/libgfortran/generated/maxloc1_16_i2.c
+++ b/libgfortran/generated/maxloc1_16_i2.c
@@ -117,8 +117,9 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c
index 1fbda541ae3..394c0160261 100644
--- a/libgfortran/generated/maxloc1_16_i4.c
+++ b/libgfortran/generated/maxloc1_16_i4.c
@@ -117,8 +117,9 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c
index 59be84cd62c..5cff65dece4 100644
--- a/libgfortran/generated/maxloc1_16_i8.c
+++ b/libgfortran/generated/maxloc1_16_i8.c
@@ -117,8 +117,9 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c
index 3a8c8b7a376..32af8cd8854 100644
--- a/libgfortran/generated/maxloc1_16_r10.c
+++ b/libgfortran/generated/maxloc1_16_r10.c
@@ -117,8 +117,9 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c
index 60b97249ada..d695ad8ec5d 100644
--- a/libgfortran/generated/maxloc1_16_r16.c
+++ b/libgfortran/generated/maxloc1_16_r16.c
@@ -117,8 +117,9 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c
index a36a9d1133c..05dfbe380a7 100644
--- a/libgfortran/generated/maxloc1_16_r4.c
+++ b/libgfortran/generated/maxloc1_16_r4.c
@@ -117,8 +117,9 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c
index 9c659c0d3a6..a060e0620a8 100644
--- a/libgfortran/generated/maxloc1_16_r8.c
+++ b/libgfortran/generated/maxloc1_16_r8.c
@@ -117,8 +117,9 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c
index 1d9132888cd..2244456c154 100644
--- a/libgfortran/generated/maxloc1_4_i1.c
+++ b/libgfortran/generated/maxloc1_4_i1.c
@@ -117,8 +117,9 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c
index 92a08bef0bd..d0f260c962d 100644
--- a/libgfortran/generated/maxloc1_4_i16.c
+++ b/libgfortran/generated/maxloc1_4_i16.c
@@ -117,8 +117,9 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c
index b03d90a9592..5415ebabacf 100644
--- a/libgfortran/generated/maxloc1_4_i2.c
+++ b/libgfortran/generated/maxloc1_4_i2.c
@@ -117,8 +117,9 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c
index dc90ec29d8d..291b919945d 100644
--- a/libgfortran/generated/maxloc1_4_i4.c
+++ b/libgfortran/generated/maxloc1_4_i4.c
@@ -117,8 +117,9 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c
index 78da94438cd..97a904dc687 100644
--- a/libgfortran/generated/maxloc1_4_i8.c
+++ b/libgfortran/generated/maxloc1_4_i8.c
@@ -117,8 +117,9 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c
index 1c83f62f728..07ccb242ae4 100644
--- a/libgfortran/generated/maxloc1_4_r10.c
+++ b/libgfortran/generated/maxloc1_4_r10.c
@@ -117,8 +117,9 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c
index a31d0ac5afa..5ecfffd7b04 100644
--- a/libgfortran/generated/maxloc1_4_r16.c
+++ b/libgfortran/generated/maxloc1_4_r16.c
@@ -117,8 +117,9 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c
index 49d9cd5463b..f859cc76199 100644
--- a/libgfortran/generated/maxloc1_4_r4.c
+++ b/libgfortran/generated/maxloc1_4_r4.c
@@ -117,8 +117,9 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c
index 822680a4941..5d673420fd9 100644
--- a/libgfortran/generated/maxloc1_4_r8.c
+++ b/libgfortran/generated/maxloc1_4_r8.c
@@ -117,8 +117,9 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c
index 5c607532dbc..f9ea707ab95 100644
--- a/libgfortran/generated/maxloc1_8_i1.c
+++ b/libgfortran/generated/maxloc1_8_i1.c
@@ -117,8 +117,9 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c
index feefc084883..478a8bc87b0 100644
--- a/libgfortran/generated/maxloc1_8_i16.c
+++ b/libgfortran/generated/maxloc1_8_i16.c
@@ -117,8 +117,9 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c
index 8e4868d7308..972767f6558 100644
--- a/libgfortran/generated/maxloc1_8_i2.c
+++ b/libgfortran/generated/maxloc1_8_i2.c
@@ -117,8 +117,9 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c
index cb9d14d8d1d..e3b566d57ec 100644
--- a/libgfortran/generated/maxloc1_8_i4.c
+++ b/libgfortran/generated/maxloc1_8_i4.c
@@ -117,8 +117,9 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c
index 8b8f2a96914..e30e104dfc6 100644
--- a/libgfortran/generated/maxloc1_8_i8.c
+++ b/libgfortran/generated/maxloc1_8_i8.c
@@ -117,8 +117,9 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c
index 6aa6ec1941c..01e30f660e4 100644
--- a/libgfortran/generated/maxloc1_8_r10.c
+++ b/libgfortran/generated/maxloc1_8_r10.c
@@ -117,8 +117,9 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c
index 59db207cfc0..fbe72d1874f 100644
--- a/libgfortran/generated/maxloc1_8_r16.c
+++ b/libgfortran/generated/maxloc1_8_r16.c
@@ -117,8 +117,9 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c
index 3640a5dea96..3985d684fe4 100644
--- a/libgfortran/generated/maxloc1_8_r4.c
+++ b/libgfortran/generated/maxloc1_8_r4.c
@@ -117,8 +117,9 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c
index 93c7c78aec7..6e7745b31ba 100644
--- a/libgfortran/generated/maxloc1_8_r8.c
+++ b/libgfortran/generated/maxloc1_8_r8.c
@@ -117,8 +117,9 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c
index 5158e2a60cc..901f4e7f2a7 100644
--- a/libgfortran/generated/maxval_i1.c
+++ b/libgfortran/generated/maxval_i1.c
@@ -116,8 +116,9 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c
index a10c8fa57c9..c082e856922 100644
--- a/libgfortran/generated/maxval_i16.c
+++ b/libgfortran/generated/maxval_i16.c
@@ -116,8 +116,9 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c
index 3819e0e0101..87865e1b49b 100644
--- a/libgfortran/generated/maxval_i2.c
+++ b/libgfortran/generated/maxval_i2.c
@@ -116,8 +116,9 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c
index 1076336a02f..3fa4a10b1bf 100644
--- a/libgfortran/generated/maxval_i4.c
+++ b/libgfortran/generated/maxval_i4.c
@@ -116,8 +116,9 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c
index f527983097c..8b2106d209f 100644
--- a/libgfortran/generated/maxval_i8.c
+++ b/libgfortran/generated/maxval_i8.c
@@ -116,8 +116,9 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c
index fd775c0e4d5..a076190e8af 100644
--- a/libgfortran/generated/maxval_r10.c
+++ b/libgfortran/generated/maxval_r10.c
@@ -116,8 +116,9 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c
index 671ce1499f9..1e36379048b 100644
--- a/libgfortran/generated/maxval_r16.c
+++ b/libgfortran/generated/maxval_r16.c
@@ -116,8 +116,9 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c
index 674142274e9..222a4e3beee 100644
--- a/libgfortran/generated/maxval_r4.c
+++ b/libgfortran/generated/maxval_r4.c
@@ -116,8 +116,9 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c
index 136ef20794c..163ec5a1b03 100644
--- a/libgfortran/generated/maxval_r8.c
+++ b/libgfortran/generated/maxval_r8.c
@@ -116,8 +116,9 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MAXVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MAXVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MAXVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MAXVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MAXVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c
index 9529997a374..d0d6903bf41 100644
--- a/libgfortran/generated/minloc0_16_i1.c
+++ b/libgfortran/generated/minloc0_16_i1.c
@@ -77,13 +77,13 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c
index 667bfd8a349..59c1d0abbf8 100644
--- a/libgfortran/generated/minloc0_16_i16.c
+++ b/libgfortran/generated/minloc0_16_i16.c
@@ -77,13 +77,13 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c
index a5c499410bd..0df6bd189c5 100644
--- a/libgfortran/generated/minloc0_16_i2.c
+++ b/libgfortran/generated/minloc0_16_i2.c
@@ -77,13 +77,13 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c
index 7c9292cddb3..48bb60be737 100644
--- a/libgfortran/generated/minloc0_16_i4.c
+++ b/libgfortran/generated/minloc0_16_i4.c
@@ -77,13 +77,13 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c
index 022e49c9707..b92f7e43031 100644
--- a/libgfortran/generated/minloc0_16_i8.c
+++ b/libgfortran/generated/minloc0_16_i8.c
@@ -77,13 +77,13 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c
index a99c5307afc..6480a8dd681 100644
--- a/libgfortran/generated/minloc0_16_r10.c
+++ b/libgfortran/generated/minloc0_16_r10.c
@@ -77,13 +77,13 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c
index 2b2dcaacb23..325c8f68d50 100644
--- a/libgfortran/generated/minloc0_16_r16.c
+++ b/libgfortran/generated/minloc0_16_r16.c
@@ -77,13 +77,13 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c
index f265ae47561..2376d4034b6 100644
--- a/libgfortran/generated/minloc0_16_r4.c
+++ b/libgfortran/generated/minloc0_16_r4.c
@@ -77,13 +77,13 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c
index 59429f22ee9..e72abab2c5b 100644
--- a/libgfortran/generated/minloc0_16_r8.c
+++ b/libgfortran/generated/minloc0_16_r8.c
@@ -77,13 +77,13 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c
index 24463ead318..ce045a28e73 100644
--- a/libgfortran/generated/minloc0_4_i1.c
+++ b/libgfortran/generated/minloc0_4_i1.c
@@ -77,13 +77,13 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c
index ddcbc60eab9..9ae856e686c 100644
--- a/libgfortran/generated/minloc0_4_i16.c
+++ b/libgfortran/generated/minloc0_4_i16.c
@@ -77,13 +77,13 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c
index 60b2c3fcb57..c33e99cfedb 100644
--- a/libgfortran/generated/minloc0_4_i2.c
+++ b/libgfortran/generated/minloc0_4_i2.c
@@ -77,13 +77,13 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c
index 6431f38ba59..9d7eda6c839 100644
--- a/libgfortran/generated/minloc0_4_i4.c
+++ b/libgfortran/generated/minloc0_4_i4.c
@@ -77,13 +77,13 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c
index 6ffeac577fc..046e040daf0 100644
--- a/libgfortran/generated/minloc0_4_i8.c
+++ b/libgfortran/generated/minloc0_4_i8.c
@@ -77,13 +77,13 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c
index e4f10024c50..8f7b9247868 100644
--- a/libgfortran/generated/minloc0_4_r10.c
+++ b/libgfortran/generated/minloc0_4_r10.c
@@ -77,13 +77,13 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c
index 0f9fb980467..1539192ca15 100644
--- a/libgfortran/generated/minloc0_4_r16.c
+++ b/libgfortran/generated/minloc0_4_r16.c
@@ -77,13 +77,13 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c
index 14c63b35e13..86ffdb8c6ef 100644
--- a/libgfortran/generated/minloc0_4_r4.c
+++ b/libgfortran/generated/minloc0_4_r4.c
@@ -77,13 +77,13 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c
index 168d0ad2621..e78cdd898f5 100644
--- a/libgfortran/generated/minloc0_4_r8.c
+++ b/libgfortran/generated/minloc0_4_r8.c
@@ -77,13 +77,13 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c
index 6dcafbae05d..5872d85560d 100644
--- a/libgfortran/generated/minloc0_8_i1.c
+++ b/libgfortran/generated/minloc0_8_i1.c
@@ -77,13 +77,13 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c
index f2afae1e643..b56409a050c 100644
--- a/libgfortran/generated/minloc0_8_i16.c
+++ b/libgfortran/generated/minloc0_8_i16.c
@@ -77,13 +77,13 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c
index d0dd1374427..63cd947c42d 100644
--- a/libgfortran/generated/minloc0_8_i2.c
+++ b/libgfortran/generated/minloc0_8_i2.c
@@ -77,13 +77,13 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c
index a4c921acfe3..5092f89f706 100644
--- a/libgfortran/generated/minloc0_8_i4.c
+++ b/libgfortran/generated/minloc0_8_i4.c
@@ -77,13 +77,13 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c
index 26aa9476cf4..e1b99ef9f94 100644
--- a/libgfortran/generated/minloc0_8_i8.c
+++ b/libgfortran/generated/minloc0_8_i8.c
@@ -77,13 +77,13 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c
index b1705ebc5fd..600b3aa6af0 100644
--- a/libgfortran/generated/minloc0_8_r10.c
+++ b/libgfortran/generated/minloc0_8_r10.c
@@ -77,13 +77,13 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c
index 84b95baa6a5..fa4b5cd1d56 100644
--- a/libgfortran/generated/minloc0_8_r16.c
+++ b/libgfortran/generated/minloc0_8_r16.c
@@ -77,13 +77,13 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c
index d7b8d547ece..1347f15c8a8 100644
--- a/libgfortran/generated/minloc0_8_r4.c
+++ b/libgfortran/generated/minloc0_8_r4.c
@@ -77,13 +77,13 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c
index 6ac0bfe1b00..6a7b2f0d6b0 100644
--- a/libgfortran/generated/minloc0_8_r8.c
+++ b/libgfortran/generated/minloc0_8_r8.c
@@ -77,13 +77,13 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -203,18 +203,19 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " MINLOC intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " MINLOC intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -222,8 +223,8 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -360,7 +361,7 @@ sminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c
index c1baf547b4b..f4abfa8f0d1 100644
--- a/libgfortran/generated/minloc1_16_i1.c
+++ b/libgfortran/generated/minloc1_16_i1.c
@@ -117,8 +117,9 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c
index db992cb4a7c..40b86eadc6c 100644
--- a/libgfortran/generated/minloc1_16_i16.c
+++ b/libgfortran/generated/minloc1_16_i16.c
@@ -117,8 +117,9 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c
index 523a4affff4..f7057b2c849 100644
--- a/libgfortran/generated/minloc1_16_i2.c
+++ b/libgfortran/generated/minloc1_16_i2.c
@@ -117,8 +117,9 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c
index e8d5fc397c6..3cf6f0de83f 100644
--- a/libgfortran/generated/minloc1_16_i4.c
+++ b/libgfortran/generated/minloc1_16_i4.c
@@ -117,8 +117,9 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c
index 8c3e4e48242..a0838687ba8 100644
--- a/libgfortran/generated/minloc1_16_i8.c
+++ b/libgfortran/generated/minloc1_16_i8.c
@@ -117,8 +117,9 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c
index 7aa89a947cc..20b1c5789a7 100644
--- a/libgfortran/generated/minloc1_16_r10.c
+++ b/libgfortran/generated/minloc1_16_r10.c
@@ -117,8 +117,9 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c
index 5b814451d60..40fcbaea3f9 100644
--- a/libgfortran/generated/minloc1_16_r16.c
+++ b/libgfortran/generated/minloc1_16_r16.c
@@ -117,8 +117,9 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c
index b3c61552ffe..76e7efaf0eb 100644
--- a/libgfortran/generated/minloc1_16_r4.c
+++ b/libgfortran/generated/minloc1_16_r4.c
@@ -117,8 +117,9 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c
index 0a4b1b50777..97ca8661dfb 100644
--- a/libgfortran/generated/minloc1_16_r8.c
+++ b/libgfortran/generated/minloc1_16_r8.c
@@ -117,8 +117,9 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c
index 9cebebe10a0..330c0d9b91a 100644
--- a/libgfortran/generated/minloc1_4_i1.c
+++ b/libgfortran/generated/minloc1_4_i1.c
@@ -117,8 +117,9 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c
index a984a153d38..a142adb9630 100644
--- a/libgfortran/generated/minloc1_4_i16.c
+++ b/libgfortran/generated/minloc1_4_i16.c
@@ -117,8 +117,9 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c
index 685f9793b73..d7a92804094 100644
--- a/libgfortran/generated/minloc1_4_i2.c
+++ b/libgfortran/generated/minloc1_4_i2.c
@@ -117,8 +117,9 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c
index f44a631d352..c6b12e84e26 100644
--- a/libgfortran/generated/minloc1_4_i4.c
+++ b/libgfortran/generated/minloc1_4_i4.c
@@ -117,8 +117,9 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c
index f6858c02820..bac4eb5fc82 100644
--- a/libgfortran/generated/minloc1_4_i8.c
+++ b/libgfortran/generated/minloc1_4_i8.c
@@ -117,8 +117,9 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c
index 8e359fe1519..0579519ab0d 100644
--- a/libgfortran/generated/minloc1_4_r10.c
+++ b/libgfortran/generated/minloc1_4_r10.c
@@ -117,8 +117,9 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c
index 11cb9c8f962..d74d26dc605 100644
--- a/libgfortran/generated/minloc1_4_r16.c
+++ b/libgfortran/generated/minloc1_4_r16.c
@@ -117,8 +117,9 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c
index 31aa1f7a621..050ed5c3c79 100644
--- a/libgfortran/generated/minloc1_4_r4.c
+++ b/libgfortran/generated/minloc1_4_r4.c
@@ -117,8 +117,9 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c
index a7a56b67f89..483cd19f262 100644
--- a/libgfortran/generated/minloc1_4_r8.c
+++ b/libgfortran/generated/minloc1_4_r8.c
@@ -117,8 +117,9 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c
index 1fae32b3fb6..1fc81d106e2 100644
--- a/libgfortran/generated/minloc1_8_i1.c
+++ b/libgfortran/generated/minloc1_8_i1.c
@@ -117,8 +117,9 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c
index 0d31c944b85..ecbabc7a981 100644
--- a/libgfortran/generated/minloc1_8_i16.c
+++ b/libgfortran/generated/minloc1_8_i16.c
@@ -117,8 +117,9 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c
index 88655757ddc..2c03443258e 100644
--- a/libgfortran/generated/minloc1_8_i2.c
+++ b/libgfortran/generated/minloc1_8_i2.c
@@ -117,8 +117,9 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c
index 31ee2385b36..945423748c5 100644
--- a/libgfortran/generated/minloc1_8_i4.c
+++ b/libgfortran/generated/minloc1_8_i4.c
@@ -117,8 +117,9 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c
index 13577aba741..df801458e09 100644
--- a/libgfortran/generated/minloc1_8_i8.c
+++ b/libgfortran/generated/minloc1_8_i8.c
@@ -117,8 +117,9 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c
index 726aa1c8937..364bf5c6f04 100644
--- a/libgfortran/generated/minloc1_8_r10.c
+++ b/libgfortran/generated/minloc1_8_r10.c
@@ -117,8 +117,9 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c
index aaf9797856d..b8ad0950ec5 100644
--- a/libgfortran/generated/minloc1_8_r16.c
+++ b/libgfortran/generated/minloc1_8_r16.c
@@ -117,8 +117,9 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c
index 6b0bcec629c..e9df66c669f 100644
--- a/libgfortran/generated/minloc1_8_r4.c
+++ b/libgfortran/generated/minloc1_8_r4.c
@@ -117,8 +117,9 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c
index 8a8d266393d..7d2cfff7fed 100644
--- a/libgfortran/generated/minloc1_8_r8.c
+++ b/libgfortran/generated/minloc1_8_r8.c
@@ -117,8 +117,9 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINLOC intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINLOC intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -130,8 +131,8 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -323,8 +324,8 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -335,8 +336,8 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINLOC intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINLOC intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -460,7 +461,7 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINLOC intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c
index ef31ba0c8d8..1789ec9fcfa 100644
--- a/libgfortran/generated/minval_i1.c
+++ b/libgfortran/generated/minval_i1.c
@@ -116,8 +116,9 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c
index 8d7bf50c4ae..2916256e3eb 100644
--- a/libgfortran/generated/minval_i16.c
+++ b/libgfortran/generated/minval_i16.c
@@ -116,8 +116,9 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c
index c3d63f6482b..73bf18b6167 100644
--- a/libgfortran/generated/minval_i2.c
+++ b/libgfortran/generated/minval_i2.c
@@ -116,8 +116,9 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c
index 48ea446db9c..8d6e52a2ac0 100644
--- a/libgfortran/generated/minval_i4.c
+++ b/libgfortran/generated/minval_i4.c
@@ -116,8 +116,9 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c
index cd2100a05ac..22cf462d060 100644
--- a/libgfortran/generated/minval_i8.c
+++ b/libgfortran/generated/minval_i8.c
@@ -116,8 +116,9 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c
index 10d0302d4ee..f4d467c0d99 100644
--- a/libgfortran/generated/minval_r10.c
+++ b/libgfortran/generated/minval_r10.c
@@ -116,8 +116,9 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ sminval_r10 (gfc_array_r10 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c
index da6e7963a3a..7ba19c99c1b 100644
--- a/libgfortran/generated/minval_r16.c
+++ b/libgfortran/generated/minval_r16.c
@@ -116,8 +116,9 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ sminval_r16 (gfc_array_r16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c
index 745889a8131..3b29f2f5d3b 100644
--- a/libgfortran/generated/minval_r4.c
+++ b/libgfortran/generated/minval_r4.c
@@ -116,8 +116,9 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ sminval_r4 (gfc_array_r4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c
index 1b0fec0174a..adca8b28c7d 100644
--- a/libgfortran/generated/minval_r8.c
+++ b/libgfortran/generated/minval_r8.c
@@ -116,8 +116,9 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " MINVAL intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " MINVAL intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -317,8 +318,8 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -329,8 +330,8 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " MINVAL intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " MINVAL intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -449,7 +450,7 @@ sminval_r8 (gfc_array_r8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in MINVAL intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_c10.c b/libgfortran/generated/product_c10.c
index 701835f9a43..def678ab953 100644
--- a/libgfortran/generated/product_c10.c
+++ b/libgfortran/generated/product_c10.c
@@ -116,8 +116,9 @@ product_c10 (gfc_array_c10 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_c10 (gfc_array_c10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_c16.c b/libgfortran/generated/product_c16.c
index 1d58a768756..d8750aef5b0 100644
--- a/libgfortran/generated/product_c16.c
+++ b/libgfortran/generated/product_c16.c
@@ -116,8 +116,9 @@ product_c16 (gfc_array_c16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_c16 (gfc_array_c16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_c4.c b/libgfortran/generated/product_c4.c
index 3754fcb5cae..7cac33fc8c6 100644
--- a/libgfortran/generated/product_c4.c
+++ b/libgfortran/generated/product_c4.c
@@ -116,8 +116,9 @@ product_c4 (gfc_array_c4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_c4 (gfc_array_c4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_c8.c b/libgfortran/generated/product_c8.c
index 6312451b794..e4f0f6bfd30 100644
--- a/libgfortran/generated/product_c8.c
+++ b/libgfortran/generated/product_c8.c
@@ -116,8 +116,9 @@ product_c8 (gfc_array_c8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_c8 (gfc_array_c8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_i1.c b/libgfortran/generated/product_i1.c
index 7003129a4f7..5a428cad202 100644
--- a/libgfortran/generated/product_i1.c
+++ b/libgfortran/generated/product_i1.c
@@ -116,8 +116,9 @@ product_i1 (gfc_array_i1 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_i1 (gfc_array_i1 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_i16.c b/libgfortran/generated/product_i16.c
index 3c448082195..a1593a4f66a 100644
--- a/libgfortran/generated/product_i16.c
+++ b/libgfortran/generated/product_i16.c
@@ -116,8 +116,9 @@ product_i16 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_i2.c b/libgfortran/generated/product_i2.c
index ca57d29dc20..16793f89579 100644
--- a/libgfortran/generated/product_i2.c
+++ b/libgfortran/generated/product_i2.c
@@ -116,8 +116,9 @@ product_i2 (gfc_array_i2 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_i2 (gfc_array_i2 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_i4.c b/libgfortran/generated/product_i4.c
index d31eb6e1598..cbace913d6a 100644
--- a/libgfortran/generated/product_i4.c
+++ b/libgfortran/generated/product_i4.c
@@ -116,8 +116,9 @@ product_i4 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_i8.c b/libgfortran/generated/product_i8.c
index 8867aaea2fd..f1fc56718a8 100644
--- a/libgfortran/generated/product_i8.c
+++ b/libgfortran/generated/product_i8.c
@@ -116,8 +116,9 @@ product_i8 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_r10.c b/libgfortran/generated/product_r10.c
index 235b8a664dd..4b7c5803096 100644
--- a/libgfortran/generated/product_r10.c
+++ b/libgfortran/generated/product_r10.c
@@ -116,8 +116,9 @@ product_r10 (gfc_array_r10 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_r10 (gfc_array_r10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_r16.c b/libgfortran/generated/product_r16.c
index 2f837e303f1..b18155bd73c 100644
--- a/libgfortran/generated/product_r16.c
+++ b/libgfortran/generated/product_r16.c
@@ -116,8 +116,9 @@ product_r16 (gfc_array_r16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_r16 (gfc_array_r16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_r4.c b/libgfortran/generated/product_r4.c
index 4e6c3d178ef..754cac2bfb1 100644
--- a/libgfortran/generated/product_r4.c
+++ b/libgfortran/generated/product_r4.c
@@ -116,8 +116,9 @@ product_r4 (gfc_array_r4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_r4 (gfc_array_r4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/product_r8.c b/libgfortran/generated/product_r8.c
index 849d404869d..5f68856a8b0 100644
--- a/libgfortran/generated/product_r8.c
+++ b/libgfortran/generated/product_r8.c
@@ -116,8 +116,9 @@ product_r8 (gfc_array_r8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " PRODUCT intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " PRODUCT intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ product_r8 (gfc_array_r8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " PRODUCT intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " PRODUCT intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in PRODUCT intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c
index f3da3849808..e495a0ba497 100644
--- a/libgfortran/generated/sum_c10.c
+++ b/libgfortran/generated/sum_c10.c
@@ -116,8 +116,9 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_c10 (gfc_array_c10 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_c16.c b/libgfortran/generated/sum_c16.c
index df79daf313a..c73083a930c 100644
--- a/libgfortran/generated/sum_c16.c
+++ b/libgfortran/generated/sum_c16.c
@@ -116,8 +116,9 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_c16 (gfc_array_c16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_c4.c b/libgfortran/generated/sum_c4.c
index 9ef9e8399f7..6f32327ad0b 100644
--- a/libgfortran/generated/sum_c4.c
+++ b/libgfortran/generated/sum_c4.c
@@ -116,8 +116,9 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_c4 (gfc_array_c4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_c8.c b/libgfortran/generated/sum_c8.c
index a7f7392e747..80db1101cfe 100644
--- a/libgfortran/generated/sum_c8.c
+++ b/libgfortran/generated/sum_c8.c
@@ -116,8 +116,9 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_c8 (gfc_array_c8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_i1.c b/libgfortran/generated/sum_i1.c
index 8740fb79b5e..c652712d4e7 100644
--- a/libgfortran/generated/sum_i1.c
+++ b/libgfortran/generated/sum_i1.c
@@ -116,8 +116,9 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_i16.c b/libgfortran/generated/sum_i16.c
index 6500d178fa4..43a29a2956f 100644
--- a/libgfortran/generated/sum_i16.c
+++ b/libgfortran/generated/sum_i16.c
@@ -116,8 +116,9 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_i2.c b/libgfortran/generated/sum_i2.c
index 10202c35ac8..6c6fcc1116a 100644
--- a/libgfortran/generated/sum_i2.c
+++ b/libgfortran/generated/sum_i2.c
@@ -116,8 +116,9 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_i4.c b/libgfortran/generated/sum_i4.c
index 4d0e8a4a963..e28d2c96fdf 100644
--- a/libgfortran/generated/sum_i4.c
+++ b/libgfortran/generated/sum_i4.c
@@ -116,8 +116,9 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_i8.c b/libgfortran/generated/sum_i8.c
index 8b280a81e0d..6e824f1ca56 100644
--- a/libgfortran/generated/sum_i8.c
+++ b/libgfortran/generated/sum_i8.c
@@ -116,8 +116,9 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_r10.c b/libgfortran/generated/sum_r10.c
index 0fd8775f93c..1ebd1ed5425 100644
--- a/libgfortran/generated/sum_r10.c
+++ b/libgfortran/generated/sum_r10.c
@@ -116,8 +116,9 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_r10 (gfc_array_r10 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_r16.c b/libgfortran/generated/sum_r16.c
index 8903b64d8bc..0038983a6b4 100644
--- a/libgfortran/generated/sum_r16.c
+++ b/libgfortran/generated/sum_r16.c
@@ -116,8 +116,9 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_r16 (gfc_array_r16 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_r4.c b/libgfortran/generated/sum_r4.c
index 1d3f2d09008..1f058dcbda0 100644
--- a/libgfortran/generated/sum_r4.c
+++ b/libgfortran/generated/sum_r4.c
@@ -116,8 +116,9 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_r4 (gfc_array_r4 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/generated/sum_r8.c b/libgfortran/generated/sum_r8.c
index d049876d5f2..82a03bc81f7 100644
--- a/libgfortran/generated/sum_r8.c
+++ b/libgfortran/generated/sum_r8.c
@@ -116,8 +116,9 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " SUM intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " SUM intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -129,8 +130,8 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -316,8 +317,8 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -328,8 +329,8 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " SUM intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " SUM intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -448,7 +449,7 @@ ssum_r8 (gfc_array_r8 * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in SUM intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/m4/iforeach.m4 b/libgfortran/m4/iforeach.m4
index a49d33b9311..071900b03b8 100644
--- a/libgfortran/m4/iforeach.m4
+++ b/libgfortran/m4/iforeach.m4
@@ -44,13 +44,13 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in u_name intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " u_name intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " u_name intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	}
     }
 
@@ -162,18 +162,19 @@ void
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in u_name intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	  if (ret_extent != rank)
 	    runtime_error ("Incorrect extent in return value of"
-			   " u_name intrnisic: is %ld, should be %d",
-			   (long int) ret_extent, rank);
+			   " u_name intrnisic: is %ld, should be %ld",
+			   (long int) ret_extent, (long int) rank);
 	
 	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
 	  if (rank != mask_rank)
 	    runtime_error ("rank of MASK argument in u_name intrnisic"
-	                   "should be %d, is %d", rank, mask_rank);
+	                   "should be %ld, is %ld", (long int) rank,
+			   (long int) mask_rank);
 
 	  for (n=0; n<rank; n++)
 	    {
@@ -181,8 +182,8 @@ void
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " u_name intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " u_name intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -318,7 +319,7 @@ void
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in u_name intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)
diff --git a/libgfortran/m4/ifunction.m4 b/libgfortran/m4/ifunction.m4
index 965fff8acc5..9769e4d2ddb 100644
--- a/libgfortran/m4/ifunction.m4
+++ b/libgfortran/m4/ifunction.m4
@@ -99,8 +99,9 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 	runtime_error ("rank of return array incorrect in"
-		       " u_name intrinsic: is %d, should be %d",
-		       GFC_DESCRIPTOR_RANK (retarray), rank);
+		       " u_name intrinsic: is %ld, should be %ld",
+		       (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+		       (long int) rank);
 
       if (compile_options.bounds_check)
 	{
@@ -112,8 +113,8 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " u_name intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " u_name intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
 	}
@@ -299,8 +300,8 @@ void
 		- retarray->dim[n].lbound;
 	      if (extent[n] != ret_extent)
 		runtime_error ("Incorrect extent in return value of"
-			       " u_name intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " u_name intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) ret_extent, (long int) extent[n]);
 	    }
           for (n=0; n<= rank; n++)
@@ -311,8 +312,8 @@ void
 	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
 	      if (array_extent != mask_extent)
 		runtime_error ("Incorrect extent in MASK argument of"
-			       " u_name intrinsic in dimension %d:"
-			       " is %ld, should be %ld", n + 1,
+			       " u_name intrinsic in dimension %ld:"
+			       " is %ld, should be %ld", (long int) n + 1,
 			       (long int) mask_extent, (long int) array_extent);
 	    }
 	}
@@ -430,7 +431,7 @@ void
 	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
 	  if (ret_rank != 1)
 	    runtime_error ("rank of return array in u_name intrinsic"
-			   " should be 1, is %d", ret_rank);
+			   " should be 1, is %ld", (long int) ret_rank);
 
 	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
 	    if (ret_extent != rank)