re PR fortran/54613 ([F08] Add FINDLOC plus support MAXLOC/MINLOC with KIND=/BACK=)

2018-01-15  Thomas Koenig  <tkoenig@gcc.gnu.org>

	PR fortran/54613
	* gfortran.h (gfc_check_f): Rename f4ml to f5ml.
	(gfc_logical_4_kind): New macro
	* intrinsic.h (gfc_simplify_minloc): Add a gfc_expr *argument.
	(gfc_simplify_maxloc): Likewise.
	(gfc_resolve_maxloc): Likewise.
	(gfc_resolve_minloc): Likewise.
	* check.c (gfc_check_minloc_maxloc): Add checking for "back"
	argument; also raise error if it is used (for now). Add it
	if it isn't present.
	* intrinsic.c (add_sym_4ml): Rename to
	(add_sym_5ml), adjust for extra argument.
	(add_functions): Add "back" constant. Adjust maxloc and minloc
	for back argument.
	* iresolve.c (gfc_resolve_maxloc): Add back argument. If back is
	not of gfc_logical_4_kind, convert.
	(gfc_resolve_minloc): Likewise.
	* simplify.c (gfc_simplify_minloc): Add back argument.
	(gfc_simplify_maxloc): Likewise.
	* trans-intinsic.c (gfc_conv_intrinsic_minmaxloc): Rename last
	argument to %VAL to ensure passing by value.
	(gfc_conv_intrinsic_function): Call gfc_conv_intrinsic_minmaxloc
	also for library calls.

2018-01-15  Thomas Koenig  <tkoenig@gcc.gnu.org>

	PR fortran/54613
	* m4/iparm.m4: Add back_arg macro if in minloc or maxloc.
	* m4/iforeach-s.m4: Add optional argument back with back_arg
	macro. Improve m4 quoting. If HAVE_BACK_ARG is defined, assert
	that back is non-true.
	* m4/iforeach.m4: Likewise.
	* m4/ifunction-s.m4: Likewise.
	* m4/ifunction.m4: Likewise.
	* m4/maxloc0.m4: Include assert.h
	* m4/minloc0.m4: Likewise.
	* m4/maxloc0s.m4: #define HAVE_BACK_ARG.
	* m4/minloc0s.m4: Likewise.
	* m4/maxloc1s.m4: Likewise.
	* m4/minloc1s.m4: Likewise.
	* m4/maxloc1.m4: Include assert.h, #define HAVE_BACK_ARG.
	* m4/minloc1.m4: Likewise.
	* m4/maxloc2s.m4: Add assert.h, add back_arg, assert that
	back is non-true.
	* m4/minloc2s.m4: Likewise.
	* generated/iall_i1.c: Regenerated.
	* generated/iall_i16.c: Regenerated.
	* generated/iall_i2.c: Regenerated.
	* generated/iall_i4.c: Regenerated.
	* generated/iall_i8.c: Regenerated.
	* generated/iany_i1.c: Regenerated.
	* generated/iany_i16.c: Regenerated.
	* generated/iany_i2.c: Regenerated.
	* generated/iany_i4.c: Regenerated.
	* generated/iany_i8.c: Regenerated.
	* generated/iparity_i1.c: Regenerated.
	* generated/iparity_i16.c: Regenerated.
	* generated/iparity_i2.c: Regenerated.
	* generated/iparity_i4.c: Regenerated.
	* generated/iparity_i8.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_16_s1.c: Regenerated.
	* generated/maxloc0_16_s4.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_4_s1.c: Regenerated.
	* generated/maxloc0_4_s4.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/maxloc0_8_s1.c: Regenerated.
	* generated/maxloc0_8_s4.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_16_s1.c: Regenerated.
	* generated/maxloc1_16_s4.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_4_s1.c: Regenerated.
	* generated/maxloc1_4_s4.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/maxloc1_8_s1.c: Regenerated.
	* generated/maxloc1_8_s4.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_16_s1.c: Regenerated.
	* generated/minloc0_16_s4.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_4_s1.c: Regenerated.
	* generated/minloc0_4_s4.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/minloc0_8_s1.c: Regenerated.
	* generated/minloc0_8_s4.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_16_s1.c: Regenerated.
	* generated/minloc1_16_s4.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_4_s1.c: Regenerated.
	* generated/minloc1_4_s4.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/minloc1_8_s1.c: Regenerated.
	* generated/minloc1_8_s4.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/norm2_r10.c: Regenerated.
	* generated/norm2_r16.c: Regenerated.
	* generated/norm2_r4.c: Regenerated.
	* generated/norm2_r8.c: Regenerated.
	* generated/parity_l1.c: Regenerated.
	* generated/parity_l16.c: Regenerated.
	* generated/parity_l2.c: Regenerated.
	* generated/parity_l4.c: Regenerated.
	* generated/parity_l8.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.

2018-01-15  Thomas Koenig  <tkoenig@gcc.gnu.org>

	PR fortran/54613
	* gfortran.dg/minmaxloc_9.f90: New test.
	* gfortran.dg/minmaxloc_10.f90: New test.
	* gfortran.dg/minmaxloc_11.f90: New test.

From-SVN: r256705

240 files changed, 3713 insertions, 1064 deletions

diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index 7533171..453dc74 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,29 @@
+2018-01-15  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/54613
+	* gfortran.h (gfc_check_f): Rename f4ml to f5ml.
+	(gfc_logical_4_kind): New macro
+	* intrinsic.h (gfc_simplify_minloc): Add a gfc_expr *argument.
+	(gfc_simplify_maxloc): Likewise.
+	(gfc_resolve_maxloc): Likewise.
+	(gfc_resolve_minloc): Likewise.
+	* check.c (gfc_check_minloc_maxloc): Add checking for "back"
+	argument; also raise error if it is used (for now). Add it
+	if it isn't present.
+	* intrinsic.c (add_sym_4ml): Rename to
+	(add_sym_5ml), adjust for extra argument.
+	(add_functions): Add "back" constant. Adjust maxloc and minloc
+	for back argument.
+	* iresolve.c (gfc_resolve_maxloc): Add back argument. If back is
+	not of gfc_logical_4_kind, convert.
+	(gfc_resolve_minloc): Likewise.
+	* simplify.c (gfc_simplify_minloc): Add back argument.
+	(gfc_simplify_maxloc): Likewise.
+	* trans-intinsic.c (gfc_conv_intrinsic_minmaxloc): Rename last
+	argument to %VAL to ensure passing by value.
+	(gfc_conv_intrinsic_function): Call gfc_conv_intrinsic_minmaxloc
+	also for library calls.
+
 2018-01-13  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
 
 	PR fortran/82007
@@ -6,7 +32,7 @@
 	format string or format label is present.
 	* trans-io.c (get_dtio_proc): Likewise. (transfer_expr): Fix
 	whitespace.
-	
+
 2018-01-13  Thomas Koenig <tkoenig@gcc.gnu.org>
 
 	PR fortran/83744
diff --git a/gcc/fortran/check.c b/gcc/fortran/check.c
index fccb927..a2c8b52 100644
--- a/gcc/fortran/check.c
+++ b/gcc/fortran/check.c
@@ -3265,12 +3265,13 @@ gfc_check_matmul (gfc_expr *matrix_a, gfc_expr *matrix_b)
 	 DIM	MASK
 
    I.e. in the case of minloc(array,mask), mask will be in the second
-   position of the argument list and we'll have to fix that up.  */
+   position of the argument list and we'll have to fix that up.  Also,
+   add the BACK argument if that isn't present.  */
 
 bool
 gfc_check_minloc_maxloc (gfc_actual_arglist *ap)
 {
-  gfc_expr *a, *m, *d, *k;
+  gfc_expr *a, *m, *d, *k, *b;
 
   a = ap->expr;
   if (!int_or_real_or_char_check_f2003 (a, 0) || !array_check (a, 0))
@@ -3279,6 +3280,26 @@ gfc_check_minloc_maxloc (gfc_actual_arglist *ap)
   d = ap->next->expr;
   m = ap->next->next->expr;
   k = ap->next->next->next->expr;
+  b = ap->next->next->next->next->expr;
+
+  if (b)
+    {
+      if (!type_check (b, 4, BT_LOGICAL) || !scalar_check (b,4))
+	return false;
+
+      /* TODO: Remove this once BACK is actually implemented.  */
+      if (b->expr_type != EXPR_CONSTANT || b->value.logical != 0)
+	{
+	  gfc_error ("BACK argument to %qs intrinsic not yet "
+		     "implemented", gfc_current_intrinsic);
+	  return false;
+	}
+    }
+  else
+    {
+      b = gfc_get_logical_expr (gfc_default_logical_kind, NULL, 0);
+      ap->next->next->next->next->expr = b;
+    }
 
   if (m == NULL && d != NULL && d->ts.type == BT_LOGICAL
       && ap->next->name == NULL)
diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h
index b3f8e42..6ddf450 100644
--- a/gcc/fortran/gfortran.h
+++ b/gcc/fortran/gfortran.h
@@ -1999,7 +1999,7 @@ typedef union
   bool (*f1m)(gfc_actual_arglist *);
   bool (*f2)(struct gfc_expr *, struct gfc_expr *);
   bool (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
-  bool (*f4ml)(gfc_actual_arglist *);
+  bool (*f5ml)(gfc_actual_arglist *);
   bool (*f3red)(gfc_actual_arglist *);
   bool (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
 	    struct gfc_expr *);
@@ -2915,6 +2915,8 @@ extern int gfc_size_kind;
 extern int gfc_numeric_storage_size;
 extern int gfc_character_storage_size;
 
+#define gfc_logical_4_kind 4
+
 /* symbol.c */
 void gfc_clear_new_implicit (void);
 bool gfc_add_new_implicit_range (int, int);
diff --git a/gcc/fortran/intrinsic.c b/gcc/fortran/intrinsic.c
index ed732aa..4844cee 100644
--- a/gcc/fortran/intrinsic.c
+++ b/gcc/fortran/intrinsic.c
@@ -687,29 +687,33 @@ add_sym_3 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt ty
    might have to be reordered.  */
 
 static void
-add_sym_4ml (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
+add_sym_5ml (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
 	     int kind, int standard,
 	     bool (*check) (gfc_actual_arglist *),
-	     gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
-	     void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
+	     gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *,
+				    gfc_expr *, gfc_expr *),
+	     void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *,
+			      gfc_expr *, gfc_expr *),
 	     const char *a1, bt type1, int kind1, int optional1,
 	     const char *a2, bt type2, int kind2, int optional2,
 	     const char *a3, bt type3, int kind3, int optional3,
-	     const char *a4, bt type4, int kind4, int optional4)
+	     const char *a4, bt type4, int kind4, int optional4,
+	     const char *a5, bt type5, int kind5, int optional5)
 {
   gfc_check_f cf;
   gfc_simplify_f sf;
   gfc_resolve_f rf;
 
-  cf.f4ml = check;
-  sf.f4 = simplify;
-  rf.f4 = resolve;
+  cf.f5ml = check;
+  sf.f5 = simplify;
+  rf.f5 = resolve;
 
   add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
 	   a1, type1, kind1, optional1, INTENT_IN,
 	   a2, type2, kind2, optional2, INTENT_IN,
 	   a3, type3, kind3, optional3, INTENT_IN,
 	   a4, type4, kind4, optional4, INTENT_IN,
+	   a5, type5, kind5, optional5, INTENT_IN,
 	   (void *) 0);
 }
 
@@ -1242,7 +1246,7 @@ add_functions (void)
     *num = "number", *tm = "time", *nm = "name", *md = "mode",
     *vl = "values", *p1 = "path1", *p2 = "path2", *com = "command",
     *ca = "coarray", *sub = "sub", *dist = "distance", *failed="failed",
-    *c_ptr_1 = "c_ptr_1", *c_ptr_2 = "c_ptr_2";
+    *c_ptr_1 = "c_ptr_1", *c_ptr_2 = "c_ptr_2", *back = "back";
 
   int di, dr, dd, dl, dc, dz, ii;
 
@@ -2457,10 +2461,11 @@ add_functions (void)
 
   make_generic ("maxexponent", GFC_ISYM_MAXEXPONENT, GFC_STD_F95);
 
-  add_sym_4ml ("maxloc", GFC_ISYM_MAXLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
+  add_sym_5ml ("maxloc", GFC_ISYM_MAXLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
 	       gfc_check_minloc_maxloc, gfc_simplify_maxloc, gfc_resolve_maxloc,
 	       ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
-	       msk, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL);
+	       msk, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL,
+	       back, BT_LOGICAL, dl, OPTIONAL);
 
   make_generic ("maxloc", GFC_ISYM_MAXLOC, GFC_STD_F95);
 
@@ -2533,11 +2538,12 @@ add_functions (void)
 
   make_generic ("minexponent", GFC_ISYM_MINEXPONENT, GFC_STD_F95);
 
-  add_sym_4ml ("minloc", GFC_ISYM_MINLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
+  add_sym_5ml ("minloc", GFC_ISYM_MINLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
 	       gfc_check_minloc_maxloc, gfc_simplify_minloc, gfc_resolve_minloc,
 	       ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
-	       msk, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL);
-
+	       msk, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL,
+	       back, BT_LOGICAL, dl, OPTIONAL);
+	       
   make_generic ("minloc", GFC_ISYM_MINLOC, GFC_STD_F95);
 
   add_sym_3red ("minval", GFC_ISYM_MINVAL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
@@ -4500,7 +4506,7 @@ check_specific (gfc_intrinsic_sym *specific, gfc_expr *expr, int error_flag)
   if (!do_ts29113_check (specific, *ap))
     return false;
 
-  if (specific->check.f4ml == gfc_check_minloc_maxloc)
+  if (specific->check.f5ml == gfc_check_minloc_maxloc)
     /* This is special because we might have to reorder the argument list.  */
     t = gfc_check_minloc_maxloc (*ap);
   else if (specific->check.f3red == gfc_check_minval_maxval)
diff --git a/gcc/fortran/intrinsic.h b/gcc/fortran/intrinsic.h
index a7db830..7615dd1 100644
--- a/gcc/fortran/intrinsic.h
+++ b/gcc/fortran/intrinsic.h
@@ -348,10 +348,12 @@ gfc_expr *gfc_simplify_maskr (gfc_expr *, gfc_expr *);
 gfc_expr *gfc_simplify_merge (gfc_expr *, gfc_expr *, gfc_expr *);
 gfc_expr *gfc_simplify_merge_bits (gfc_expr *, gfc_expr *, gfc_expr *);
 gfc_expr *gfc_simplify_min (gfc_expr *);
-gfc_expr *gfc_simplify_minloc (gfc_expr*, gfc_expr *, gfc_expr *, gfc_expr *);
+gfc_expr *gfc_simplify_minloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *,
+			       gfc_expr *);
 gfc_expr *gfc_simplify_minval (gfc_expr *, gfc_expr*, gfc_expr*);
 gfc_expr *gfc_simplify_max (gfc_expr *);
-gfc_expr *gfc_simplify_maxloc (gfc_expr*, gfc_expr *, gfc_expr *, gfc_expr *);
+gfc_expr *gfc_simplify_maxloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *,
+			       gfc_expr *);
 gfc_expr *gfc_simplify_maxval (gfc_expr *, gfc_expr*, gfc_expr*);
 gfc_expr *gfc_simplify_maxexponent (gfc_expr *);
 gfc_expr *gfc_simplify_minexponent (gfc_expr *);
@@ -540,7 +542,7 @@ void gfc_resolve_logical (gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_lstat (gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_matmul (gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_max (gfc_expr *, gfc_actual_arglist *);
-void gfc_resolve_maxloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
+void gfc_resolve_maxloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_maxval (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_mclock (gfc_expr *);
 void gfc_resolve_mclock8 (gfc_expr *);
@@ -548,7 +550,7 @@ void gfc_resolve_mask (gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_merge (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_merge_bits (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_min (gfc_expr *, gfc_actual_arglist *);
-void gfc_resolve_minloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
+void gfc_resolve_minloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_minval (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_mod (gfc_expr *, gfc_expr *, gfc_expr *);
 void gfc_resolve_modulo (gfc_expr *, gfc_expr *, gfc_expr *);
diff --git a/gcc/fortran/iresolve.c b/gcc/fortran/iresolve.c
index 11f2569..9a4e199 100644
--- a/gcc/fortran/iresolve.c
+++ b/gcc/fortran/iresolve.c
@@ -1697,7 +1697,7 @@ gfc_resolve_max (gfc_expr *f, gfc_actual_arglist *args)
 
 void
 gfc_resolve_maxloc (gfc_expr *f, gfc_expr *array, gfc_expr *dim,
-		    gfc_expr *mask, gfc_expr *kind)
+		    gfc_expr *mask, gfc_expr *kind, gfc_expr *back)
 {
   const char *name;
   int i, j, idim;
@@ -1781,6 +1781,15 @@ gfc_resolve_maxloc (gfc_expr *f, gfc_expr *array, gfc_expr *dim,
       ts.kind = fkind;
       gfc_convert_type_warn (f, &ts, 2, 0);
     }
+
+  if (back->ts.kind != gfc_logical_4_kind)
+    {
+      gfc_typespec ts;
+      gfc_clear_ts (&ts);
+      ts.type = BT_LOGICAL;
+      ts.kind = gfc_logical_4_kind;
+      gfc_convert_type_warn (back, &ts, 2, 0);
+    }
 }
 
 
@@ -1907,7 +1916,7 @@ gfc_resolve_min (gfc_expr *f, gfc_actual_arglist *args)
 
 void
 gfc_resolve_minloc (gfc_expr *f, gfc_expr *array, gfc_expr *dim,
-		    gfc_expr *mask, gfc_expr *kind)
+		    gfc_expr *mask, gfc_expr *kind, gfc_expr *back)
 {
   const char *name;
   int i, j, idim;
@@ -1986,6 +1995,15 @@ gfc_resolve_minloc (gfc_expr *f, gfc_expr *array, gfc_expr *dim,
       ts.kind = fkind;
       gfc_convert_type_warn (f, &ts, 2, 0);
     }
+
+  if (back->ts.kind != gfc_logical_4_kind)
+    {
+      gfc_typespec ts;
+      gfc_clear_ts (&ts);
+      ts.type = BT_LOGICAL;
+      ts.kind = gfc_logical_4_kind;
+      gfc_convert_type_warn (back, &ts, 2, 0);
+    }
 }
 
 
diff --git a/gcc/fortran/simplify.c b/gcc/fortran/simplify.c
index 3e5abd4..b7c6b02 100644
--- a/gcc/fortran/simplify.c
+++ b/gcc/fortran/simplify.c
@@ -5343,13 +5343,15 @@ gfc_simplify_minmaxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask,
 }
 
 gfc_expr *
-gfc_simplify_minloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind)
+gfc_simplify_minloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind,
+		     gfc_expr *back ATTRIBUTE_UNUSED)
 {
   return gfc_simplify_minmaxloc (array, dim, mask, kind, -1);
 }
 
 gfc_expr *
-gfc_simplify_maxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind)
+gfc_simplify_maxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind,
+		     gfc_expr *back ATTRIBUTE_UNUSED)
 {
   return gfc_simplify_minmaxloc (array, dim, mask, kind, 1);
 }
diff --git a/gcc/fortran/trans-intrinsic.c b/gcc/fortran/trans-intrinsic.c
index 7fe8286..f4defb0 100644
--- a/gcc/fortran/trans-intrinsic.c
+++ b/gcc/fortran/trans-intrinsic.c
@@ -4562,13 +4562,22 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
   tree pos;
   int n;
 
+  actual = expr->value.function.actual;
+
+  /* The last argument, BACK, is passed by value. Ensure that
+     by setting its name to %VAL. */
+  for (gfc_actual_arglist *a = actual; a; a = a->next)
+    {
+      if (a->next == NULL)
+	a->name = "%VAL";
+    }
+
   if (se->ss)
     {
       gfc_conv_intrinsic_funcall (se, expr);
       return;
     }
 
-  actual = expr->value.function.actual;
   arrayexpr = actual->expr;
 
   /* Special case for character maxloc.  Remove unneeded actual
@@ -4576,22 +4585,19 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
   
   if (arrayexpr->ts.type == BT_CHARACTER)
     {
-      gfc_actual_arglist *a2, *a3, *a4;
-      a2 = actual->next;
-      a3 = a2->next;
-      a4 = a3->next;
-      a4->next = NULL;
-      if (a3->expr == NULL)
-	{
-	  actual->next = NULL;
-	  gfc_free_actual_arglist (a2);
-	}
-      else
+      gfc_actual_arglist *a, *b;
+      a = actual;
+      while (a->next)
 	{
-	  actual->next = a3;  /* dim */
-	  a3->next = NULL;
-	  a2->next = a4;
-	  gfc_free_actual_arglist (a4);
+	  b = a->next;
+	  if (b->expr == NULL || strcmp (b->name, "dim") == 0)
+	    {
+	      a->next = b->next;
+	      b->next = NULL;
+	      gfc_free_actual_arglist (b);
+	    }
+	  else
+	    a = b;
 	}
       gfc_conv_intrinsic_funcall (se, expr);
       return;
@@ -8647,6 +8653,14 @@ gfc_conv_intrinsic_function (gfc_se * se, gfc_expr * expr)
 	      conv_generic_with_optional_char_arg (se, expr, 1, 3);
 	      break;
 
+	    case GFC_ISYM_MINLOC:
+	      gfc_conv_intrinsic_minmaxloc (se, expr, LT_EXPR);
+	      break;
+	      
+	    case GFC_ISYM_MAXLOC:
+	      gfc_conv_intrinsic_minmaxloc (se, expr, GT_EXPR);
+	      break;
+
 	    default:
 	      gfc_conv_intrinsic_funcall (se, expr);
 	      break;
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 9f1742e..382ec74 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,10 @@
+2018-01-15  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/54613
+	* gfortran.dg/minmaxloc_9.f90: New test.
+	* gfortran.dg/minmaxloc_10.f90: New test.
+	* gfortran.dg/minmaxloc_11.f90: New test.
+
 2018-01-15  H.J. Lu  <hongjiu.lu@intel.com>
 
 	PR target/83839
diff --git a/gcc/testsuite/gfortran.dg/minmaxloc_10.f90 b/gcc/testsuite/gfortran.dg/minmaxloc_10.f90
new file mode 100644
index 0000000..932a40b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/minmaxloc_10.f90
@@ -0,0 +1,118 @@
+! { dg-do run }
+! { dg-additional-options "-fdefault-integer-8" }
+! Check max/minloc with eight-bytes logicals.
+!
+program test
+  implicit none
+  integer :: i(1), j(-1:1), res(1)
+  logical, volatile :: m(3), m2(3)
+  m = (/ .false., .false., .false. /)
+  m2 = (/ .false., .true., .false. /)
+  call check(1, 0, MAXLOC((/ 42, 23, 11 /), DIM=1, MASK=.FALSE.))
+  call check(2, 0, MAXLOC((/ 42, 23, 11 /), DIM=1, MASK=m))
+  call check(3, 2, MAXLOC((/ 42, 23, 11 /), DIM=1, MASK=m2))
+  call check(4, 0, MAXLOC(i(1:0), DIM=1, MASK=.TRUE.))
+  call check(5, 0, MAXLOC(i(1:0), DIM=1, MASK=.FALSE.))
+  call check(6, 0, MAXLOC(i(1:0), DIM=1, MASK=m(1:0)))
+  call check(7, 0, MAXLOC(i(1:0), DIM=1))
+  call check(8, 0, MINLOC((/ 42, 23, 11 /), DIM=1, MASK=.FALSE.))
+  call check(9, 0, MINLOC((/ 42, 23, 11 /), DIM=1, MASK=m))
+  call check(10, 0, MINLOC(i(1:0), DIM=1, MASK=.FALSE.))
+  call check(11,0, MINLOC(i(1:0), DIM=1, MASK=m(1:0)))
+  call check(12,0, MINLOC(i(1:0), DIM=1, MASK=.TRUE.))
+  call check(13,0, MINLOC(i(1:0), DIM=1))
+
+  j = (/ 1, 2, 1 /); call check(14, 2, MAXLOC(j, DIM=1))
+  j = (/ 1, 2, 3 /); call check(15, 3, MAXLOC(j, DIM=1))
+  j = (/ 3, 2, 1 /); call check(16, 1, MAXLOC(j, DIM=1))
+  j = (/ 1, 2, 1 /); call check(17, 1, MINLOC(j, DIM=1))
+  j = (/ 1, 2, 3 /); call check(18, 1, MINLOC(j, DIM=1))
+  j = (/ 3, 2, 1 /); call check(19, 3, MINLOC(j, DIM=1))
+
+  j = (/ 1, 2, 1 /); call check(20, 2, MAXLOC(j, DIM=1,mask=.true.))
+  j = (/ 1, 2, 3 /); call check(21, 3, MAXLOC(j, DIM=1,mask=.true.))
+  j = (/ 3, 2, 1 /); call check(22, 1, MAXLOC(j, DIM=1,mask=.true.))
+  j = (/ 1, 2, 1 /); call check(23, 1, MINLOC(j, DIM=1,mask=.true.))
+  j = (/ 1, 2, 3 /); call check(24, 1, MINLOC(j, DIM=1,mask=.true.))
+  j = (/ 3, 2, 1 /); call check(25, 3, MINLOC(j, DIM=1,mask=.true.))
+
+  j = (/ 1, 2, 1 /); call check(26, 0, MAXLOC(j, DIM=1,mask=.false.))
+  j = (/ 1, 2, 3 /); call check(27, 0, MAXLOC(j, DIM=1,mask=.false.))
+  j = (/ 3, 2, 1 /); call check(28, 0, MAXLOC(j, DIM=1,mask=.false.))
+  j = (/ 1, 2, 1 /); call check(29, 0, MINLOC(j, DIM=1,mask=.false.))
+  j = (/ 1, 2, 3 /); call check(30, 0, MINLOC(j, DIM=1,mask=.false.))
+  j = (/ 3, 2, 1 /); call check(31, 0, MINLOC(j, DIM=1,mask=.false.))
+
+  j = (/ 1, 2, 1 /); call check(32, 0, MAXLOC(j, DIM=1,mask=m))
+  j = (/ 1, 2, 3 /); call check(33, 0, MAXLOC(j, DIM=1,mask=m))
+  j = (/ 3, 2, 1 /); call check(34, 0, MAXLOC(j, DIM=1,mask=m))
+  j = (/ 1, 2, 1 /); call check(35, 0, MINLOC(j, DIM=1,mask=m))
+  j = (/ 1, 2, 3 /); call check(36, 0, MINLOC(j, DIM=1,mask=m))
+  j = (/ 3, 2, 1 /); call check(37, 0, MINLOC(j, DIM=1,mask=m))
+
+  j = (/ 1, 2, 1 /); call check(38, 2, MAXLOC(j, DIM=1,mask=m2))
+  j = (/ 1, 2, 3 /); call check(39, 2, MAXLOC(j, DIM=1,mask=m2))
+  j = (/ 3, 2, 1 /); call check(40, 2, MAXLOC(j, DIM=1,mask=m2))
+  j = (/ 1, 2, 1 /); call check(41, 2, MINLOC(j, DIM=1,mask=m2))
+  j = (/ 1, 2, 3 /); call check(42, 2, MINLOC(j, DIM=1,mask=m2))
+  j = (/ 3, 2, 1 /); call check(43, 2, MINLOC(j, DIM=1,mask=m2))
+
+! Check the library minloc and maxloc
+  res = MAXLOC((/ 42, 23, 11 /), MASK=.FALSE.); call check(44, 0,  res(1))
+  res = MAXLOC((/ 42, 23, 11 /), MASK=m); call check(45, 0,  res(1))
+  res = MAXLOC((/ 42, 23, 11 /), MASK=m2); call check(46, 2,  res(1))
+  res = MAXLOC(i(1:0), MASK=.TRUE.); call check(47, 0,  res(1))
+  res = MAXLOC(i(1:0), MASK=.FALSE.); call check(48, 0,  res(1))
+  res = MAXLOC(i(1:0), MASK=m(1:0)); call check(49, 0,  res(1))
+  res = MAXLOC(i(1:0)); call check(50, 0,  res(1))
+  res = MINLOC((/ 42, 23, 11 /), MASK=.FALSE.); call check(51, 0, res(1))
+  res = MINLOC((/ 42, 23, 11 /), MASK=m); call check(52, 0, res(1))
+  res = MINLOC(i(1:0), MASK=.FALSE.); call check(53, 0, res(1))
+  res = MINLOC(i(1:0), MASK=m(1:0)); call check(54,0, res(1))
+  res = MINLOC(i(1:0), MASK=.TRUE.); call check(55,0, res(1))
+  res = MINLOC(i(1:0)); call check(56,0, res(1))
+
+  j = (/ 1, 2, 1 /); res = MAXLOC(j); call check(57, 2,  res(1))
+  j = (/ 1, 2, 3 /); res = MAXLOC(j); call check(58, 3,  res(1))
+  j = (/ 3, 2, 1 /); res = MAXLOC(j); call check(59, 1,  res(1))
+  j = (/ 1, 2, 1 /); res = MINLOC(j); call check(60, 1, res(1))
+  j = (/ 1, 2, 3 /); res = MINLOC(j); call check(61, 1, res(1))
+  j = (/ 3, 2, 1 /); res = MINLOC(j); call check(62, 3, res(1))
+
+  j = (/ 1, 2, 1 /); res = MAXLOC(j,mask=.true.); call check(63, 2,  res(1))
+  j = (/ 1, 2, 3 /); res = MAXLOC(j,mask=.true.); call check(65, 3,  res(1))
+  j = (/ 3, 2, 1 /); res = MAXLOC(j,mask=.true.); call check(66, 1,  res(1))
+  j = (/ 1, 2, 1 /); res = MINLOC(j,mask=.true.); call check(67, 1, res(1))
+  j = (/ 1, 2, 3 /); res = MINLOC(j,mask=.true.); call check(68, 1, res(1))
+  j = (/ 3, 2, 1 /); res = MINLOC(j,mask=.true.); call check(69, 3, res(1))
+
+  j = (/ 1, 2, 1 /); res = MAXLOC(j,mask=.false.); call check(70, 0,  res(1))
+  j = (/ 1, 2, 3 /); res = MAXLOC(j,mask=.false.); call check(71, 0,  res(1))
+  j = (/ 3, 2, 1 /); res = MAXLOC(j,mask=.false.); call check(72, 0,  res(1))
+  j = (/ 1, 2, 1 /); res = MINLOC(j,mask=.false.); call check(73, 0, res(1))
+  j = (/ 1, 2, 3 /); res = MINLOC(j,mask=.false.); call check(74, 0, res(1))
+  j = (/ 3, 2, 1 /); res = MINLOC(j,mask=.false.); call check(75, 0, res(1))
+
+  j = (/ 1, 2, 1 /); res = MAXLOC(j,mask=m); call check(76, 0,  res(1))
+  j = (/ 1, 2, 3 /); res = MAXLOC(j,mask=m); call check(77, 0,  res(1))
+  j = (/ 3, 2, 1 /); res = MAXLOC(j,mask=m); call check(78, 0,  res(1))
+  j = (/ 1, 2, 1 /); res = MINLOC(j,mask=m); call check(79, 0, res(1))
+  j = (/ 1, 2, 3 /); res = MINLOC(j,mask=m); call check(80, 0, res(1))
+  j = (/ 3, 2, 1 /); res = MINLOC(j,mask=m);call check(81, 0, res(1))
+
+  j = (/ 1, 2, 1 /); res = MAXLOC(j,mask=m2); call check(82, 2,  res(1))
+  j = (/ 1, 2, 3 /); res = MAXLOC(j,mask=m2); call check(83, 2,  res(1))
+  j = (/ 3, 2, 1 /); res = MAXLOC(j,mask=m2); call check(84, 2,  res(1))
+  j = (/ 1, 2, 1 /); res = MINLOC(j,mask=m2); call check(85, 2, res(1))
+  j = (/ 1, 2, 3 /); res = MINLOC(j,mask=m2); call check(86, 2, res(1))
+  j = (/ 3, 2, 1 /); res = MINLOC(j,mask=m2); call check(87, 2, res(1))
+
+contains
+subroutine check(n, i,j)
+  integer, value, intent(in) :: i,j,n
+  if(i /= j) then
+     call abort()
+!    print *, 'ERROR: Test',n,' expected ',i,' received ', j
+  end if
+end subroutine check
+end program
diff --git a/gcc/testsuite/gfortran.dg/minmaxloc_11.f90 b/gcc/testsuite/gfortran.dg/minmaxloc_11.f90
new file mode 100644
index 0000000..1ab8eb1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/minmaxloc_11.f90
@@ -0,0 +1,9 @@
+! { dg-do run }
+program main
+  character(len=3), dimension(2) :: a
+  a(1) = 'aaa'
+  a(2) = 'bbb'
+  if (maxloc(a,dim=1) /= 2) call abort
+  if (minloc(a,dim=1) /= 1) call abort
+
+end program main
diff --git a/gcc/testsuite/gfortran.dg/minmaxloc_9.f90 b/gcc/testsuite/gfortran.dg/minmaxloc_9.f90
new file mode 100644
index 0000000..badadac
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/minmaxloc_9.f90
@@ -0,0 +1,11 @@
+! { dg-do compile }
+! Check for a few restrictions on the back argument to
+! minloc and maxloc.
+program main
+  integer, dimension(3) :: a
+  a = [1,2,3]
+  print *,minloc(a,back=42) ! { dg-error "must be LOGICAL" }
+  print *,minloc(a,back=[.true.,.false.]) ! { dg-error "must be a scalar" }
+  print *,maxloc(a,back=42) ! { dg-error "must be LOGICAL" }
+  print *,maxloc(a,back=[.true.,.false.]) ! { dg-error "must be a scalar" }
+end program main
diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog
index c6c3628..55b087f 100644
--- a/libgfortran/ChangeLog
+++ b/libgfortran/ChangeLog
@@ -1,3 +1,225 @@
+2018-01-15  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/54613
+	* m4/iparm.m4: Add back_arg macro if in minloc or maxloc.
+	* m4/iforeach-s.m4: Add optional argument back with back_arg
+	macro. Improve m4 quoting. If HAVE_BACK_ARG is defined, assert
+	that back is non-true.
+	* m4/iforeach.m4: Likewise.
+	* m4/ifunction-s.m4: Likewise.
+	* m4/ifunction.m4: Likewise.
+	* m4/maxloc0.m4: Include assert.h
+	* m4/minloc0.m4: Likewise.
+	* m4/maxloc0s.m4: #define HAVE_BACK_ARG.
+	* m4/minloc0s.m4: Likewise.
+	* m4/maxloc1s.m4: Likewise.
+	* m4/minloc1s.m4: Likewise.
+	* m4/maxloc1.m4: Include assert.h, #define HAVE_BACK_ARG.
+	* m4/minloc1.m4: Likewise.
+	* m4/maxloc2s.m4: Add assert.h, add back_arg, assert that
+	back is non-true.
+	* m4/minloc2s.m4: Likewise.
+	* generated/iall_i1.c: Regenerated.
+	* generated/iall_i16.c: Regenerated.
+	* generated/iall_i2.c: Regenerated.
+	* generated/iall_i4.c: Regenerated.
+	* generated/iall_i8.c: Regenerated.
+	* generated/iany_i1.c: Regenerated.
+	* generated/iany_i16.c: Regenerated.
+	* generated/iany_i2.c: Regenerated.
+	* generated/iany_i4.c: Regenerated.
+	* generated/iany_i8.c: Regenerated.
+	* generated/iparity_i1.c: Regenerated.
+	* generated/iparity_i16.c: Regenerated.
+	* generated/iparity_i2.c: Regenerated.
+	* generated/iparity_i4.c: Regenerated.
+	* generated/iparity_i8.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_16_s1.c: Regenerated.
+	* generated/maxloc0_16_s4.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_4_s1.c: Regenerated.
+	* generated/maxloc0_4_s4.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/maxloc0_8_s1.c: Regenerated.
+	* generated/maxloc0_8_s4.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_16_s1.c: Regenerated.
+	* generated/maxloc1_16_s4.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_4_s1.c: Regenerated.
+	* generated/maxloc1_4_s4.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/maxloc1_8_s1.c: Regenerated.
+	* generated/maxloc1_8_s4.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_16_s1.c: Regenerated.
+	* generated/minloc0_16_s4.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_4_s1.c: Regenerated.
+	* generated/minloc0_4_s4.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/minloc0_8_s1.c: Regenerated.
+	* generated/minloc0_8_s4.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_16_s1.c: Regenerated.
+	* generated/minloc1_16_s4.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_4_s1.c: Regenerated.
+	* generated/minloc1_4_s4.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/minloc1_8_s1.c: Regenerated.
+	* generated/minloc1_8_s4.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/norm2_r10.c: Regenerated.
+	* generated/norm2_r16.c: Regenerated.
+	* generated/norm2_r4.c: Regenerated.
+	* generated/norm2_r8.c: Regenerated.
+	* generated/parity_l1.c: Regenerated.
+	* generated/parity_l16.c: Regenerated.
+	* generated/parity_l2.c: Regenerated.
+	* generated/parity_l4.c: Regenerated.
+	* generated/parity_l8.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.
+
 2018-01-14  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
 
 	PR libgfortran/83811
diff --git a/libgfortran/generated/iall_i1.c b/libgfortran/generated/iall_i1.c
index bf13b79..a171ed2 100644
--- a/libgfortran/generated/iall_i1.c
+++ b/libgfortran/generated/iall_i1.c
@@ -51,6 +51,10 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siall_i1 (gfc_array_i1 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iall_i1 (retarray, array, pdim, back);
+#else
       iall_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iall_i16.c b/libgfortran/generated/iall_i16.c
index a3de245..80c89e8 100644
--- a/libgfortran/generated/iall_i16.c
+++ b/libgfortran/generated/iall_i16.c
@@ -51,6 +51,10 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miall_i16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siall_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iall_i16 (retarray, array, pdim, back);
+#else
       iall_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iall_i2.c b/libgfortran/generated/iall_i2.c
index b2b3f05..618b024 100644
--- a/libgfortran/generated/iall_i2.c
+++ b/libgfortran/generated/iall_i2.c
@@ -51,6 +51,10 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siall_i2 (gfc_array_i2 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iall_i2 (retarray, array, pdim, back);
+#else
       iall_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iall_i4.c b/libgfortran/generated/iall_i4.c
index 70a4379..808e073 100644
--- a/libgfortran/generated/iall_i4.c
+++ b/libgfortran/generated/iall_i4.c
@@ -51,6 +51,10 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siall_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iall_i4 (retarray, array, pdim, back);
+#else
       iall_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iall_i8.c b/libgfortran/generated/iall_i8.c
index 77cc4c0..c487b6c 100644
--- a/libgfortran/generated/iall_i8.c
+++ b/libgfortran/generated/iall_i8.c
@@ -51,6 +51,10 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siall_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iall_i8 (retarray, array, pdim, back);
+#else
       iall_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iany_i1.c b/libgfortran/generated/iany_i1.c
index 9673cb0..0890eed 100644
--- a/libgfortran/generated/iany_i1.c
+++ b/libgfortran/generated/iany_i1.c
@@ -51,6 +51,10 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siany_i1 (gfc_array_i1 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iany_i1 (retarray, array, pdim, back);
+#else
       iany_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iany_i16.c b/libgfortran/generated/iany_i16.c
index df60f10..126db33 100644
--- a/libgfortran/generated/iany_i16.c
+++ b/libgfortran/generated/iany_i16.c
@@ -51,6 +51,10 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miany_i16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siany_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iany_i16 (retarray, array, pdim, back);
+#else
       iany_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iany_i2.c b/libgfortran/generated/iany_i2.c
index 5b0623bd..3a26b2c 100644
--- a/libgfortran/generated/iany_i2.c
+++ b/libgfortran/generated/iany_i2.c
@@ -51,6 +51,10 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siany_i2 (gfc_array_i2 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iany_i2 (retarray, array, pdim, back);
+#else
       iany_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iany_i4.c b/libgfortran/generated/iany_i4.c
index a7effd6..8b81d00 100644
--- a/libgfortran/generated/iany_i4.c
+++ b/libgfortran/generated/iany_i4.c
@@ -51,6 +51,10 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siany_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iany_i4 (retarray, array, pdim, back);
+#else
       iany_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iany_i8.c b/libgfortran/generated/iany_i8.c
index c87ba7a..9ffc9b6 100644
--- a/libgfortran/generated/iany_i8.c
+++ b/libgfortran/generated/iany_i8.c
@@ -51,6 +51,10 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siany_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iany_i8 (retarray, array, pdim, back);
+#else
       iany_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iparity_i1.c b/libgfortran/generated/iparity_i1.c
index 4315406..b4d42402 100644
--- a/libgfortran/generated/iparity_i1.c
+++ b/libgfortran/generated/iparity_i1.c
@@ -51,6 +51,10 @@ iparity_i1 (gfc_array_i1 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miparity_i1 (gfc_array_i1 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siparity_i1 (gfc_array_i1 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iparity_i1 (retarray, array, pdim, back);
+#else
       iparity_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iparity_i16.c b/libgfortran/generated/iparity_i16.c
index 8817487..96cb108 100644
--- a/libgfortran/generated/iparity_i16.c
+++ b/libgfortran/generated/iparity_i16.c
@@ -51,6 +51,10 @@ iparity_i16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miparity_i16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siparity_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iparity_i16 (retarray, array, pdim, back);
+#else
       iparity_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iparity_i2.c b/libgfortran/generated/iparity_i2.c
index 0c73703..b077f29 100644
--- a/libgfortran/generated/iparity_i2.c
+++ b/libgfortran/generated/iparity_i2.c
@@ -51,6 +51,10 @@ iparity_i2 (gfc_array_i2 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miparity_i2 (gfc_array_i2 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siparity_i2 (gfc_array_i2 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iparity_i2 (retarray, array, pdim, back);
+#else
       iparity_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iparity_i4.c b/libgfortran/generated/iparity_i4.c
index 1f1bfa9..1b5dfe0 100644
--- a/libgfortran/generated/iparity_i4.c
+++ b/libgfortran/generated/iparity_i4.c
@@ -51,6 +51,10 @@ iparity_i4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miparity_i4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siparity_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iparity_i4 (retarray, array, pdim, back);
+#else
       iparity_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/iparity_i8.c b/libgfortran/generated/iparity_i8.c
index ad58b53..056a59b 100644
--- a/libgfortran/generated/iparity_i8.c
+++ b/libgfortran/generated/iparity_i8.c
@@ -51,6 +51,10 @@ iparity_i8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ miparity_i8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ siparity_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      iparity_i8 (retarray, array, pdim, back);
+#else
       iparity_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc0_16_i1.c b/libgfortran/generated/maxloc0_16_i1.c
index aa5ac36..25398cc 100644
--- a/libgfortran/generated/maxloc0_16_i1.c
+++ b/libgfortran/generated/maxloc0_16_i1.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void maxloc0_16_i1 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i1 * const restrict array);
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_16_i1);
 
 void
 maxloc0_16_i1 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i1 * const restrict array)
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_i1 (gfc_array_i16 * const restrict, 
-	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_16_i1);
 
 void
 mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_i1 (gfc_array_i16 * const restrict, 
-	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_16_i1);
 
 void
 smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_16_i1 (retarray, array);
+      maxloc0_16_i1 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_i16.c b/libgfortran/generated/maxloc0_16_i16.c
index f648402..3a4a744 100644
--- a/libgfortran/generated/maxloc0_16_i16.c
+++ b/libgfortran/generated/maxloc0_16_i16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void maxloc0_16_i16 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i16 * const restrict array);
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_16_i16);
 
 void
 maxloc0_16_i16 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i16 * const restrict array)
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_i16 (gfc_array_i16 * const restrict, 
-	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_16_i16);
 
 void
 mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_i16 (gfc_array_i16 * const restrict, 
-	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_16_i16);
 
 void
 smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_16_i16 (retarray, array);
+      maxloc0_16_i16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_i2.c b/libgfortran/generated/maxloc0_16_i2.c
index 825eb74..0ff8ca0 100644
--- a/libgfortran/generated/maxloc0_16_i2.c
+++ b/libgfortran/generated/maxloc0_16_i2.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void maxloc0_16_i2 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i2 * const restrict array);
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_16_i2);
 
 void
 maxloc0_16_i2 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i2 * const restrict array)
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_i2 (gfc_array_i16 * const restrict, 
-	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_16_i2);
 
 void
 mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_i2 (gfc_array_i16 * const restrict, 
-	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_16_i2);
 
 void
 smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_16_i2 (retarray, array);
+      maxloc0_16_i2 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_i4.c b/libgfortran/generated/maxloc0_16_i4.c
index 0720609..84cff67 100644
--- a/libgfortran/generated/maxloc0_16_i4.c
+++ b/libgfortran/generated/maxloc0_16_i4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void maxloc0_16_i4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i4 * const restrict array);
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_16_i4);
 
 void
 maxloc0_16_i4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i4 * const restrict array)
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_i4 (gfc_array_i16 * const restrict, 
-	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_16_i4);
 
 void
 mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_i4 (gfc_array_i16 * const restrict, 
-	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_16_i4);
 
 void
 smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_16_i4 (retarray, array);
+      maxloc0_16_i4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_i8.c b/libgfortran/generated/maxloc0_16_i8.c
index f5318e9..e276295 100644
--- a/libgfortran/generated/maxloc0_16_i8.c
+++ b/libgfortran/generated/maxloc0_16_i8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void maxloc0_16_i8 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i8 * const restrict array);
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_16_i8);
 
 void
 maxloc0_16_i8 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i8 * const restrict array)
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_i8 (gfc_array_i16 * const restrict, 
-	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_16_i8);
 
 void
 mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_i8 (gfc_array_i16 * const restrict, 
-	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_16_i8);
 
 void
 smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_16_i8 (retarray, array);
+      maxloc0_16_i8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_r10.c b/libgfortran/generated/maxloc0_16_r10.c
index 1641b3a..384487f 100644
--- a/libgfortran/generated/maxloc0_16_r10.c
+++ b/libgfortran/generated/maxloc0_16_r10.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void maxloc0_16_r10 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r10 * const restrict array);
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_16_r10);
 
 void
 maxloc0_16_r10 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r10 * const restrict array)
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_r10 (gfc_array_i16 * const restrict, 
-	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_16_r10);
 
 void
 mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_r10 (gfc_array_i16 * const restrict, 
-	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_16_r10);
 
 void
 smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_16_r10 (retarray, array);
+      maxloc0_16_r10 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_r16.c b/libgfortran/generated/maxloc0_16_r16.c
index c5409fd..10c7673 100644
--- a/libgfortran/generated/maxloc0_16_r16.c
+++ b/libgfortran/generated/maxloc0_16_r16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void maxloc0_16_r16 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r16 * const restrict array);
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_16_r16);
 
 void
 maxloc0_16_r16 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r16 * const restrict array)
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_r16 (gfc_array_i16 * const restrict, 
-	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_16_r16);
 
 void
 mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_r16 (gfc_array_i16 * const restrict, 
-	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_16_r16);
 
 void
 smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_16_r16 (retarray, array);
+      maxloc0_16_r16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_r4.c b/libgfortran/generated/maxloc0_16_r4.c
index 1d076a1..b7aaa3d 100644
--- a/libgfortran/generated/maxloc0_16_r4.c
+++ b/libgfortran/generated/maxloc0_16_r4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void maxloc0_16_r4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r4 * const restrict array);
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_16_r4);
 
 void
 maxloc0_16_r4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r4 * const restrict array)
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_r4 (gfc_array_i16 * const restrict, 
-	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_16_r4);
 
 void
 mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_r4 (gfc_array_i16 * const restrict, 
-	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_16_r4);
 
 void
 smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_16_r4 (retarray, array);
+      maxloc0_16_r4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_r8.c b/libgfortran/generated/maxloc0_16_r8.c
index 2cb175b..2ca3479 100644
--- a/libgfortran/generated/maxloc0_16_r8.c
+++ b/libgfortran/generated/maxloc0_16_r8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void maxloc0_16_r8 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r8 * const restrict array);
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_16_r8);
 
 void
 maxloc0_16_r8 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r8 * const restrict array)
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_r8 (gfc_array_i16 * const restrict, 
-	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_16_r8);
 
 void
 mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_r8 (gfc_array_i16 * const restrict, 
-	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_16_r8);
 
 void
 smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_16_r8 (retarray, array);
+      maxloc0_16_r8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_s1.c b/libgfortran/generated/maxloc0_16_s1.c
index 424237c..a05d178 100644
--- a/libgfortran/generated/maxloc0_16_s1.c
+++ b/libgfortran/generated/maxloc0_16_s1.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void maxloc0_16_s1 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len);
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(maxloc0_16_s1);
 
 void
 maxloc0_16_s1 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len)
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ maxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ maxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_s1 (gfc_array_i16 * const restrict, 
-	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mmaxloc0_16_s1);
 
 void
 mmaxloc0_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mmaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mmaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_s1 (gfc_array_i16 * const restrict, 
-	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(smaxloc0_16_s1);
 
 void
 smaxloc0_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ smaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      maxloc0_16_s1 (retarray, array, back, len);
+#else
       maxloc0_16_s1 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_16_s4.c b/libgfortran/generated/maxloc0_16_s4.c
index e0c236a..f6adf95 100644
--- a/libgfortran/generated/maxloc0_16_s4.c
+++ b/libgfortran/generated/maxloc0_16_s4.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void maxloc0_16_s4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len);
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(maxloc0_16_s4);
 
 void
 maxloc0_16_s4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len)
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ maxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ maxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mmaxloc0_16_s4 (gfc_array_i16 * const restrict, 
-	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mmaxloc0_16_s4);
 
 void
 mmaxloc0_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mmaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mmaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void smaxloc0_16_s4 (gfc_array_i16 * const restrict, 
-	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(smaxloc0_16_s4);
 
 void
 smaxloc0_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ smaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      maxloc0_16_s4 (retarray, array, back, len);
+#else
       maxloc0_16_s4 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_i1.c b/libgfortran/generated/maxloc0_4_i1.c
index 137e852..dc31e1d 100644
--- a/libgfortran/generated/maxloc0_4_i1.c
+++ b/libgfortran/generated/maxloc0_4_i1.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void maxloc0_4_i1 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i1 * const restrict array);
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_4_i1);
 
 void
 maxloc0_4_i1 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i1 * const restrict array)
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_i1 (gfc_array_i4 * const restrict, 
-	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_4_i1);
 
 void
 mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_i1 (gfc_array_i4 * const restrict, 
-	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_4_i1);
 
 void
 smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_4_i1 (retarray, array);
+      maxloc0_4_i1 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_i16.c b/libgfortran/generated/maxloc0_4_i16.c
index 880e3ca..f722600 100644
--- a/libgfortran/generated/maxloc0_4_i16.c
+++ b/libgfortran/generated/maxloc0_4_i16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void maxloc0_4_i16 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i16 * const restrict array);
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_4_i16);
 
 void
 maxloc0_4_i16 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i16 * const restrict array)
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_i16 (gfc_array_i4 * const restrict, 
-	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_4_i16);
 
 void
 mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_i16 (gfc_array_i4 * const restrict, 
-	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_4_i16);
 
 void
 smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_4_i16 (retarray, array);
+      maxloc0_4_i16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_i2.c b/libgfortran/generated/maxloc0_4_i2.c
index 98197ec..f78e20ec 100644
--- a/libgfortran/generated/maxloc0_4_i2.c
+++ b/libgfortran/generated/maxloc0_4_i2.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void maxloc0_4_i2 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i2 * const restrict array);
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_4_i2);
 
 void
 maxloc0_4_i2 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i2 * const restrict array)
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_i2 (gfc_array_i4 * const restrict, 
-	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_4_i2);
 
 void
 mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_i2 (gfc_array_i4 * const restrict, 
-	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_4_i2);
 
 void
 smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_4_i2 (retarray, array);
+      maxloc0_4_i2 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_i4.c b/libgfortran/generated/maxloc0_4_i4.c
index cc6ad84..58c3cf1 100644
--- a/libgfortran/generated/maxloc0_4_i4.c
+++ b/libgfortran/generated/maxloc0_4_i4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void maxloc0_4_i4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i4 * const restrict array);
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_4_i4);
 
 void
 maxloc0_4_i4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i4 * const restrict array)
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_i4 (gfc_array_i4 * const restrict, 
-	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_4_i4);
 
 void
 mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_i4 (gfc_array_i4 * const restrict, 
-	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_4_i4);
 
 void
 smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_4_i4 (retarray, array);
+      maxloc0_4_i4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_i8.c b/libgfortran/generated/maxloc0_4_i8.c
index 802f935..ded9b5b 100644
--- a/libgfortran/generated/maxloc0_4_i8.c
+++ b/libgfortran/generated/maxloc0_4_i8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void maxloc0_4_i8 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i8 * const restrict array);
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_4_i8);
 
 void
 maxloc0_4_i8 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i8 * const restrict array)
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_i8 (gfc_array_i4 * const restrict, 
-	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_4_i8);
 
 void
 mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_i8 (gfc_array_i4 * const restrict, 
-	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_4_i8);
 
 void
 smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_4_i8 (retarray, array);
+      maxloc0_4_i8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_r10.c b/libgfortran/generated/maxloc0_4_r10.c
index 1222096..c64bd53 100644
--- a/libgfortran/generated/maxloc0_4_r10.c
+++ b/libgfortran/generated/maxloc0_4_r10.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void maxloc0_4_r10 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r10 * const restrict array);
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_4_r10);
 
 void
 maxloc0_4_r10 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r10 * const restrict array)
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_r10 (gfc_array_i4 * const restrict, 
-	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_4_r10);
 
 void
 mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_r10 (gfc_array_i4 * const restrict, 
-	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_4_r10);
 
 void
 smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_4_r10 (retarray, array);
+      maxloc0_4_r10 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_r16.c b/libgfortran/generated/maxloc0_4_r16.c
index deaca72..4fd46a3 100644
--- a/libgfortran/generated/maxloc0_4_r16.c
+++ b/libgfortran/generated/maxloc0_4_r16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void maxloc0_4_r16 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r16 * const restrict array);
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_4_r16);
 
 void
 maxloc0_4_r16 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r16 * const restrict array)
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_r16 (gfc_array_i4 * const restrict, 
-	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_4_r16);
 
 void
 mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_r16 (gfc_array_i4 * const restrict, 
-	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_4_r16);
 
 void
 smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_4_r16 (retarray, array);
+      maxloc0_4_r16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_r4.c b/libgfortran/generated/maxloc0_4_r4.c
index aa7fca0..c168aee 100644
--- a/libgfortran/generated/maxloc0_4_r4.c
+++ b/libgfortran/generated/maxloc0_4_r4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void maxloc0_4_r4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r4 * const restrict array);
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_4_r4);
 
 void
 maxloc0_4_r4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r4 * const restrict array)
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_r4 (gfc_array_i4 * const restrict, 
-	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_4_r4);
 
 void
 mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_r4 (gfc_array_i4 * const restrict, 
-	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_4_r4);
 
 void
 smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_4_r4 (retarray, array);
+      maxloc0_4_r4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_r8.c b/libgfortran/generated/maxloc0_4_r8.c
index ba0659d..655a652 100644
--- a/libgfortran/generated/maxloc0_4_r8.c
+++ b/libgfortran/generated/maxloc0_4_r8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void maxloc0_4_r8 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r8 * const restrict array);
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_4_r8);
 
 void
 maxloc0_4_r8 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r8 * const restrict array)
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_r8 (gfc_array_i4 * const restrict, 
-	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_4_r8);
 
 void
 mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_r8 (gfc_array_i4 * const restrict, 
-	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_4_r8);
 
 void
 smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_4_r8 (retarray, array);
+      maxloc0_4_r8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_s1.c b/libgfortran/generated/maxloc0_4_s1.c
index 80759a6..b13a9b9 100644
--- a/libgfortran/generated/maxloc0_4_s1.c
+++ b/libgfortran/generated/maxloc0_4_s1.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void maxloc0_4_s1 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len);
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(maxloc0_4_s1);
 
 void
 maxloc0_4_s1 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len)
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ maxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ maxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_s1 (gfc_array_i4 * const restrict, 
-	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mmaxloc0_4_s1);
 
 void
 mmaxloc0_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mmaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mmaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_s1 (gfc_array_i4 * const restrict, 
-	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(smaxloc0_4_s1);
 
 void
 smaxloc0_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ smaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      maxloc0_4_s1 (retarray, array, back, len);
+#else
       maxloc0_4_s1 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_4_s4.c b/libgfortran/generated/maxloc0_4_s4.c
index 75eeaee..971e868 100644
--- a/libgfortran/generated/maxloc0_4_s4.c
+++ b/libgfortran/generated/maxloc0_4_s4.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void maxloc0_4_s4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len);
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(maxloc0_4_s4);
 
 void
 maxloc0_4_s4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len)
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ maxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ maxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mmaxloc0_4_s4 (gfc_array_i4 * const restrict, 
-	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mmaxloc0_4_s4);
 
 void
 mmaxloc0_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mmaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mmaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void smaxloc0_4_s4 (gfc_array_i4 * const restrict, 
-	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(smaxloc0_4_s4);
 
 void
 smaxloc0_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ smaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      maxloc0_4_s4 (retarray, array, back, len);
+#else
       maxloc0_4_s4 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_i1.c b/libgfortran/generated/maxloc0_8_i1.c
index dd07066..b86f0cb 100644
--- a/libgfortran/generated/maxloc0_8_i1.c
+++ b/libgfortran/generated/maxloc0_8_i1.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void maxloc0_8_i1 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i1 * const restrict array);
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_8_i1);
 
 void
 maxloc0_8_i1 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i1 * const restrict array)
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_i1 (gfc_array_i8 * const restrict, 
-	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_8_i1);
 
 void
 mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_i1 (gfc_array_i8 * const restrict, 
-	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_8_i1);
 
 void
 smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_8_i1 (retarray, array);
+      maxloc0_8_i1 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_i16.c b/libgfortran/generated/maxloc0_8_i16.c
index 44ab70c..710d260 100644
--- a/libgfortran/generated/maxloc0_8_i16.c
+++ b/libgfortran/generated/maxloc0_8_i16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void maxloc0_8_i16 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i16 * const restrict array);
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_8_i16);
 
 void
 maxloc0_8_i16 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i16 * const restrict array)
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_i16 (gfc_array_i8 * const restrict, 
-	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_8_i16);
 
 void
 mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_i16 (gfc_array_i8 * const restrict, 
-	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_8_i16);
 
 void
 smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_8_i16 (retarray, array);
+      maxloc0_8_i16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_i2.c b/libgfortran/generated/maxloc0_8_i2.c
index 6dfd0d8..e85fb07 100644
--- a/libgfortran/generated/maxloc0_8_i2.c
+++ b/libgfortran/generated/maxloc0_8_i2.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void maxloc0_8_i2 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i2 * const restrict array);
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_8_i2);
 
 void
 maxloc0_8_i2 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i2 * const restrict array)
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_i2 (gfc_array_i8 * const restrict, 
-	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_8_i2);
 
 void
 mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_i2 (gfc_array_i8 * const restrict, 
-	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_8_i2);
 
 void
 smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_8_i2 (retarray, array);
+      maxloc0_8_i2 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_i4.c b/libgfortran/generated/maxloc0_8_i4.c
index 01b18c3..bb6d51e 100644
--- a/libgfortran/generated/maxloc0_8_i4.c
+++ b/libgfortran/generated/maxloc0_8_i4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void maxloc0_8_i4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i4 * const restrict array);
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_8_i4);
 
 void
 maxloc0_8_i4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i4 * const restrict array)
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_i4 (gfc_array_i8 * const restrict, 
-	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_8_i4);
 
 void
 mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_i4 (gfc_array_i8 * const restrict, 
-	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_8_i4);
 
 void
 smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_8_i4 (retarray, array);
+      maxloc0_8_i4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_i8.c b/libgfortran/generated/maxloc0_8_i8.c
index df7544f..d6c6e85 100644
--- a/libgfortran/generated/maxloc0_8_i8.c
+++ b/libgfortran/generated/maxloc0_8_i8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void maxloc0_8_i8 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i8 * const restrict array);
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_8_i8);
 
 void
 maxloc0_8_i8 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i8 * const restrict array)
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_i8 (gfc_array_i8 * const restrict, 
-	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_8_i8);
 
 void
 mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_i8 (gfc_array_i8 * const restrict, 
-	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_8_i8);
 
 void
 smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_8_i8 (retarray, array);
+      maxloc0_8_i8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_r10.c b/libgfortran/generated/maxloc0_8_r10.c
index 3047b1e..333e570 100644
--- a/libgfortran/generated/maxloc0_8_r10.c
+++ b/libgfortran/generated/maxloc0_8_r10.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void maxloc0_8_r10 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r10 * const restrict array);
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_8_r10);
 
 void
 maxloc0_8_r10 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r10 * const restrict array)
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_r10 (gfc_array_i8 * const restrict, 
-	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_8_r10);
 
 void
 mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_r10 (gfc_array_i8 * const restrict, 
-	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_8_r10);
 
 void
 smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_8_r10 (retarray, array);
+      maxloc0_8_r10 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_r16.c b/libgfortran/generated/maxloc0_8_r16.c
index baf000c..ebb3118 100644
--- a/libgfortran/generated/maxloc0_8_r16.c
+++ b/libgfortran/generated/maxloc0_8_r16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void maxloc0_8_r16 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r16 * const restrict array);
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_8_r16);
 
 void
 maxloc0_8_r16 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r16 * const restrict array)
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_r16 (gfc_array_i8 * const restrict, 
-	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_8_r16);
 
 void
 mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_r16 (gfc_array_i8 * const restrict, 
-	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_8_r16);
 
 void
 smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_8_r16 (retarray, array);
+      maxloc0_8_r16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_r4.c b/libgfortran/generated/maxloc0_8_r4.c
index 48fa424..afc4696 100644
--- a/libgfortran/generated/maxloc0_8_r4.c
+++ b/libgfortran/generated/maxloc0_8_r4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void maxloc0_8_r4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r4 * const restrict array);
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_8_r4);
 
 void
 maxloc0_8_r4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r4 * const restrict array)
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_r4 (gfc_array_i8 * const restrict, 
-	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_8_r4);
 
 void
 mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_r4 (gfc_array_i8 * const restrict, 
-	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_8_r4);
 
 void
 smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_8_r4 (retarray, array);
+      maxloc0_8_r4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_r8.c b/libgfortran/generated/maxloc0_8_r8.c
index 37a25ef..e6a2fef 100644
--- a/libgfortran/generated/maxloc0_8_r8.c
+++ b/libgfortran/generated/maxloc0_8_r8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void maxloc0_8_r8 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r8 * const restrict array);
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
 export_proto(maxloc0_8_r8);
 
 void
 maxloc0_8_r8 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r8 * const restrict array)
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_r8 (gfc_array_i8 * const restrict, 
-	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mmaxloc0_8_r8);
 
 void
 mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_r8 (gfc_array_i8 * const restrict, 
-	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(smaxloc0_8_r8);
 
 void
 smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      maxloc0_8_r8 (retarray, array);
+      maxloc0_8_r8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_s1.c b/libgfortran/generated/maxloc0_8_s1.c
index 1c86ff4..2e95fa3 100644
--- a/libgfortran/generated/maxloc0_8_s1.c
+++ b/libgfortran/generated/maxloc0_8_s1.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void maxloc0_8_s1 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len);
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(maxloc0_8_s1);
 
 void
 maxloc0_8_s1 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len)
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ maxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ maxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_s1 (gfc_array_i8 * const restrict, 
-	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mmaxloc0_8_s1);
 
 void
 mmaxloc0_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mmaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mmaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_s1 (gfc_array_i8 * const restrict, 
-	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(smaxloc0_8_s1);
 
 void
 smaxloc0_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ smaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      maxloc0_8_s1 (retarray, array, back, len);
+#else
       maxloc0_8_s1 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/maxloc0_8_s4.c b/libgfortran/generated/maxloc0_8_s4.c
index 14f4658..5cc1f11 100644
--- a/libgfortran/generated/maxloc0_8_s4.c
+++ b/libgfortran/generated/maxloc0_8_s4.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void maxloc0_8_s4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len);
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(maxloc0_8_s4);
 
 void
 maxloc0_8_s4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len)
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ maxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ maxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mmaxloc0_8_s4 (gfc_array_i8 * const restrict, 
-	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mmaxloc0_8_s4);
 
 void
 mmaxloc0_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mmaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mmaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void smaxloc0_8_s4 (gfc_array_i8 * const restrict, 
-	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(smaxloc0_8_s4);
 
 void
 smaxloc0_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ smaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      maxloc0_8_s4 (retarray, array, back, len);
+#else
       maxloc0_8_s4 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c
index d1d1d5e..ff2124d 100644
--- a/libgfortran/generated/maxloc1_16_i1.c
+++ b/libgfortran/generated/maxloc1_16_i1.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_16_i1 (gfc_array_i16 * const restrict, 
-	gfc_array_i1 * const restrict, const index_type * const restrict);
+	gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_16_i1);
 
 void
 maxloc1_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_i1 (gfc_array_i16 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_16_i1);
 
 void
 mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_i1 (gfc_array_i16 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_16_i1);
 
 void
 smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_i1 (retarray, array, pdim, back);
+#else
       maxloc1_16_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c
index 27aa37d..2b0bd54 100644
--- a/libgfortran/generated/maxloc1_16_i16.c
+++ b/libgfortran/generated/maxloc1_16_i16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_16_i16 (gfc_array_i16 * const restrict, 
-	gfc_array_i16 * const restrict, const index_type * const restrict);
+	gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_16_i16);
 
 void
 maxloc1_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_i16 (gfc_array_i16 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_16_i16);
 
 void
 mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_i16 (gfc_array_i16 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_16_i16);
 
 void
 smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_i16 (retarray, array, pdim, back);
+#else
       maxloc1_16_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c
index a79088d..26c3f14 100644
--- a/libgfortran/generated/maxloc1_16_i2.c
+++ b/libgfortran/generated/maxloc1_16_i2.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_16_i2 (gfc_array_i16 * const restrict, 
-	gfc_array_i2 * const restrict, const index_type * const restrict);
+	gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_16_i2);
 
 void
 maxloc1_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_i2 (gfc_array_i16 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_16_i2);
 
 void
 mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_i2 (gfc_array_i16 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_16_i2);
 
 void
 smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_i2 (retarray, array, pdim, back);
+#else
       maxloc1_16_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c
index 852677d..aedc22a 100644
--- a/libgfortran/generated/maxloc1_16_i4.c
+++ b/libgfortran/generated/maxloc1_16_i4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_16_i4 (gfc_array_i16 * const restrict, 
-	gfc_array_i4 * const restrict, const index_type * const restrict);
+	gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_16_i4);
 
 void
 maxloc1_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_i4 (gfc_array_i16 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_16_i4);
 
 void
 mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_i4 (gfc_array_i16 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_16_i4);
 
 void
 smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_i4 (retarray, array, pdim, back);
+#else
       maxloc1_16_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c
index 4cdc1a7..d08561d 100644
--- a/libgfortran/generated/maxloc1_16_i8.c
+++ b/libgfortran/generated/maxloc1_16_i8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_16_i8 (gfc_array_i16 * const restrict, 
-	gfc_array_i8 * const restrict, const index_type * const restrict);
+	gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_16_i8);
 
 void
 maxloc1_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_i8 (gfc_array_i16 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_16_i8);
 
 void
 mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_i8 (gfc_array_i16 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_16_i8);
 
 void
 smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_i8 (retarray, array, pdim, back);
+#else
       maxloc1_16_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c
index f3f9890..a5929ee 100644
--- a/libgfortran/generated/maxloc1_16_r10.c
+++ b/libgfortran/generated/maxloc1_16_r10.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_16_r10 (gfc_array_i16 * const restrict, 
-	gfc_array_r10 * const restrict, const index_type * const restrict);
+	gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_16_r10);
 
 void
 maxloc1_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_r10 (gfc_array_i16 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_16_r10);
 
 void
 mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_r10 (gfc_array_i16 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_16_r10);
 
 void
 smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_r10 (retarray, array, pdim, back);
+#else
       maxloc1_16_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c
index 6bbef79..09da740 100644
--- a/libgfortran/generated/maxloc1_16_r16.c
+++ b/libgfortran/generated/maxloc1_16_r16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_16_r16 (gfc_array_i16 * const restrict, 
-	gfc_array_r16 * const restrict, const index_type * const restrict);
+	gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_16_r16);
 
 void
 maxloc1_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_r16 (gfc_array_i16 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_16_r16);
 
 void
 mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_r16 (gfc_array_i16 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_16_r16);
 
 void
 smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_r16 (retarray, array, pdim, back);
+#else
       maxloc1_16_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c
index 9801989..9278300 100644
--- a/libgfortran/generated/maxloc1_16_r4.c
+++ b/libgfortran/generated/maxloc1_16_r4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_16_r4 (gfc_array_i16 * const restrict, 
-	gfc_array_r4 * const restrict, const index_type * const restrict);
+	gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_16_r4);
 
 void
 maxloc1_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_r4 (gfc_array_i16 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_16_r4);
 
 void
 mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_r4 (gfc_array_i16 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_16_r4);
 
 void
 smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_r4 (retarray, array, pdim, back);
+#else
       maxloc1_16_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c
index 86cffb9..84c0c65 100644
--- a/libgfortran/generated/maxloc1_16_r8.c
+++ b/libgfortran/generated/maxloc1_16_r8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_16_r8 (gfc_array_i16 * const restrict, 
-	gfc_array_r8 * const restrict, const index_type * const restrict);
+	gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_16_r8);
 
 void
 maxloc1_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_r8 (gfc_array_i16 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_16_r8);
 
 void
 mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_r8 (gfc_array_i16 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_16_r8);
 
 void
 smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_r8 (retarray, array, pdim, back);
+#else
       maxloc1_16_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_s1.c b/libgfortran/generated/maxloc1_16_s1.c
index 16be611..84b12f3 100644
--- a/libgfortran/generated/maxloc1_16_s1.c
+++ b/libgfortran/generated/maxloc1_16_s1.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void maxloc1_16_s1 (gfc_array_i16 * const restrict, 
-	gfc_array_s1 * const restrict, const index_type * const restrict,
+	gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(maxloc1_16_s1);
 
 void
 maxloc1_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ maxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ maxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_s1 (gfc_array_i16 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mmaxloc1_16_s1);
 
 void
 mmaxloc1_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mmaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mmaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_s1 (gfc_array_i16 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc1_16_s1);
 
 void
 smaxloc1_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ smaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_s1 (retarray, array, pdim, back, string_len);
+#else
       maxloc1_16_s1 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_16_s4.c b/libgfortran/generated/maxloc1_16_s4.c
index 09bbb99..70696f2 100644
--- a/libgfortran/generated/maxloc1_16_s4.c
+++ b/libgfortran/generated/maxloc1_16_s4.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void maxloc1_16_s4 (gfc_array_i16 * const restrict, 
-	gfc_array_s4 * const restrict, const index_type * const restrict,
+	gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(maxloc1_16_s4);
 
 void
 maxloc1_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ maxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ maxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
 
 extern void mmaxloc1_16_s4 (gfc_array_i16 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mmaxloc1_16_s4);
 
 void
 mmaxloc1_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mmaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mmaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
 
 extern void smaxloc1_16_s4 (gfc_array_i16 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc1_16_s4);
 
 void
 smaxloc1_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ smaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_16_s4 (retarray, array, pdim, back, string_len);
+#else
       maxloc1_16_s4 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c
index 364d09e..7fc1f88 100644
--- a/libgfortran/generated/maxloc1_4_i1.c
+++ b/libgfortran/generated/maxloc1_4_i1.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_4_i1 (gfc_array_i4 * const restrict, 
-	gfc_array_i1 * const restrict, const index_type * const restrict);
+	gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_4_i1);
 
 void
 maxloc1_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_i1 (gfc_array_i4 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_4_i1);
 
 void
 mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_i1 (gfc_array_i4 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_4_i1);
 
 void
 smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_i1 (retarray, array, pdim, back);
+#else
       maxloc1_4_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c
index e05a9ac..14b5e55 100644
--- a/libgfortran/generated/maxloc1_4_i16.c
+++ b/libgfortran/generated/maxloc1_4_i16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_4_i16 (gfc_array_i4 * const restrict, 
-	gfc_array_i16 * const restrict, const index_type * const restrict);
+	gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_4_i16);
 
 void
 maxloc1_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_i16 (gfc_array_i4 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_4_i16);
 
 void
 mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_i16 (gfc_array_i4 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_4_i16);
 
 void
 smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_i16 (retarray, array, pdim, back);
+#else
       maxloc1_4_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c
index 3887917..9d5a98e 100644
--- a/libgfortran/generated/maxloc1_4_i2.c
+++ b/libgfortran/generated/maxloc1_4_i2.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_4_i2 (gfc_array_i4 * const restrict, 
-	gfc_array_i2 * const restrict, const index_type * const restrict);
+	gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_4_i2);
 
 void
 maxloc1_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_i2 (gfc_array_i4 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_4_i2);
 
 void
 mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_i2 (gfc_array_i4 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_4_i2);
 
 void
 smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_i2 (retarray, array, pdim, back);
+#else
       maxloc1_4_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c
index bc8a7fd..23d7028 100644
--- a/libgfortran/generated/maxloc1_4_i4.c
+++ b/libgfortran/generated/maxloc1_4_i4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_4_i4 (gfc_array_i4 * const restrict, 
-	gfc_array_i4 * const restrict, const index_type * const restrict);
+	gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_4_i4);
 
 void
 maxloc1_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_i4 (gfc_array_i4 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_4_i4);
 
 void
 mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_i4 (gfc_array_i4 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_4_i4);
 
 void
 smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_i4 (retarray, array, pdim, back);
+#else
       maxloc1_4_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c
index e1d2aee..178a20a 100644
--- a/libgfortran/generated/maxloc1_4_i8.c
+++ b/libgfortran/generated/maxloc1_4_i8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_4_i8 (gfc_array_i4 * const restrict, 
-	gfc_array_i8 * const restrict, const index_type * const restrict);
+	gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_4_i8);
 
 void
 maxloc1_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_i8 (gfc_array_i4 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_4_i8);
 
 void
 mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_i8 (gfc_array_i4 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_4_i8);
 
 void
 smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_i8 (retarray, array, pdim, back);
+#else
       maxloc1_4_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c
index 03d55cc..f359613 100644
--- a/libgfortran/generated/maxloc1_4_r10.c
+++ b/libgfortran/generated/maxloc1_4_r10.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_4_r10 (gfc_array_i4 * const restrict, 
-	gfc_array_r10 * const restrict, const index_type * const restrict);
+	gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_4_r10);
 
 void
 maxloc1_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_r10 (gfc_array_i4 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_4_r10);
 
 void
 mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_r10 (gfc_array_i4 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_4_r10);
 
 void
 smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_r10 (retarray, array, pdim, back);
+#else
       maxloc1_4_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c
index 1d86824..a0f283e 100644
--- a/libgfortran/generated/maxloc1_4_r16.c
+++ b/libgfortran/generated/maxloc1_4_r16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_4_r16 (gfc_array_i4 * const restrict, 
-	gfc_array_r16 * const restrict, const index_type * const restrict);
+	gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_4_r16);
 
 void
 maxloc1_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_r16 (gfc_array_i4 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_4_r16);
 
 void
 mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_r16 (gfc_array_i4 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_4_r16);
 
 void
 smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_r16 (retarray, array, pdim, back);
+#else
       maxloc1_4_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c
index 8dcae97..aeb4b8f 100644
--- a/libgfortran/generated/maxloc1_4_r4.c
+++ b/libgfortran/generated/maxloc1_4_r4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_4_r4 (gfc_array_i4 * const restrict, 
-	gfc_array_r4 * const restrict, const index_type * const restrict);
+	gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_4_r4);
 
 void
 maxloc1_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_r4 (gfc_array_i4 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_4_r4);
 
 void
 mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_r4 (gfc_array_i4 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_4_r4);
 
 void
 smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_r4 (retarray, array, pdim, back);
+#else
       maxloc1_4_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c
index 9c0f5b1..4385204 100644
--- a/libgfortran/generated/maxloc1_4_r8.c
+++ b/libgfortran/generated/maxloc1_4_r8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_4_r8 (gfc_array_i4 * const restrict, 
-	gfc_array_r8 * const restrict, const index_type * const restrict);
+	gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_4_r8);
 
 void
 maxloc1_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_r8 (gfc_array_i4 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_4_r8);
 
 void
 mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_r8 (gfc_array_i4 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_4_r8);
 
 void
 smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_r8 (retarray, array, pdim, back);
+#else
       maxloc1_4_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_s1.c b/libgfortran/generated/maxloc1_4_s1.c
index a882a7b..b7b7d8c 100644
--- a/libgfortran/generated/maxloc1_4_s1.c
+++ b/libgfortran/generated/maxloc1_4_s1.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void maxloc1_4_s1 (gfc_array_i4 * const restrict, 
-	gfc_array_s1 * const restrict, const index_type * const restrict,
+	gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(maxloc1_4_s1);
 
 void
 maxloc1_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ maxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ maxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_s1 (gfc_array_i4 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mmaxloc1_4_s1);
 
 void
 mmaxloc1_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mmaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mmaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_s1 (gfc_array_i4 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc1_4_s1);
 
 void
 smaxloc1_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ smaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_s1 (retarray, array, pdim, back, string_len);
+#else
       maxloc1_4_s1 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_4_s4.c b/libgfortran/generated/maxloc1_4_s4.c
index acc989c..da75949 100644
--- a/libgfortran/generated/maxloc1_4_s4.c
+++ b/libgfortran/generated/maxloc1_4_s4.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void maxloc1_4_s4 (gfc_array_i4 * const restrict, 
-	gfc_array_s4 * const restrict, const index_type * const restrict,
+	gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(maxloc1_4_s4);
 
 void
 maxloc1_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ maxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ maxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
 
 extern void mmaxloc1_4_s4 (gfc_array_i4 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mmaxloc1_4_s4);
 
 void
 mmaxloc1_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mmaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mmaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
 
 extern void smaxloc1_4_s4 (gfc_array_i4 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc1_4_s4);
 
 void
 smaxloc1_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ smaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_4_s4 (retarray, array, pdim, back, string_len);
+#else
       maxloc1_4_s4 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c
index 8087789..fa5bc4a 100644
--- a/libgfortran/generated/maxloc1_8_i1.c
+++ b/libgfortran/generated/maxloc1_8_i1.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_8_i1 (gfc_array_i8 * const restrict, 
-	gfc_array_i1 * const restrict, const index_type * const restrict);
+	gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_8_i1);
 
 void
 maxloc1_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_i1 (gfc_array_i8 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_8_i1);
 
 void
 mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_i1 (gfc_array_i8 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_8_i1);
 
 void
 smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_i1 (retarray, array, pdim, back);
+#else
       maxloc1_8_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c
index 71ad13c..2cf7531 100644
--- a/libgfortran/generated/maxloc1_8_i16.c
+++ b/libgfortran/generated/maxloc1_8_i16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_8_i16 (gfc_array_i8 * const restrict, 
-	gfc_array_i16 * const restrict, const index_type * const restrict);
+	gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_8_i16);
 
 void
 maxloc1_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_i16 (gfc_array_i8 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_8_i16);
 
 void
 mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_i16 (gfc_array_i8 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_8_i16);
 
 void
 smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_i16 (retarray, array, pdim, back);
+#else
       maxloc1_8_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c
index d89b74f..e32eafe 100644
--- a/libgfortran/generated/maxloc1_8_i2.c
+++ b/libgfortran/generated/maxloc1_8_i2.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_8_i2 (gfc_array_i8 * const restrict, 
-	gfc_array_i2 * const restrict, const index_type * const restrict);
+	gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_8_i2);
 
 void
 maxloc1_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_i2 (gfc_array_i8 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_8_i2);
 
 void
 mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_i2 (gfc_array_i8 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_8_i2);
 
 void
 smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_i2 (retarray, array, pdim, back);
+#else
       maxloc1_8_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c
index df4b218..e348550 100644
--- a/libgfortran/generated/maxloc1_8_i4.c
+++ b/libgfortran/generated/maxloc1_8_i4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_8_i4 (gfc_array_i8 * const restrict, 
-	gfc_array_i4 * const restrict, const index_type * const restrict);
+	gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_8_i4);
 
 void
 maxloc1_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_i4 (gfc_array_i8 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_8_i4);
 
 void
 mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_i4 (gfc_array_i8 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_8_i4);
 
 void
 smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_i4 (retarray, array, pdim, back);
+#else
       maxloc1_8_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c
index 946e4ca..802b74d 100644
--- a/libgfortran/generated/maxloc1_8_i8.c
+++ b/libgfortran/generated/maxloc1_8_i8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_8_i8 (gfc_array_i8 * const restrict, 
-	gfc_array_i8 * const restrict, const index_type * const restrict);
+	gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_8_i8);
 
 void
 maxloc1_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_i8 (gfc_array_i8 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_8_i8);
 
 void
 mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_i8 (gfc_array_i8 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_8_i8);
 
 void
 smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_i8 (retarray, array, pdim, back);
+#else
       maxloc1_8_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c
index a7db332..bc5f1b1 100644
--- a/libgfortran/generated/maxloc1_8_r10.c
+++ b/libgfortran/generated/maxloc1_8_r10.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_8_r10 (gfc_array_i8 * const restrict, 
-	gfc_array_r10 * const restrict, const index_type * const restrict);
+	gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_8_r10);
 
 void
 maxloc1_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_r10 (gfc_array_i8 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_8_r10);
 
 void
 mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_r10 (gfc_array_i8 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_8_r10);
 
 void
 smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_r10 (retarray, array, pdim, back);
+#else
       maxloc1_8_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c
index e118f12..54d1203 100644
--- a/libgfortran/generated/maxloc1_8_r16.c
+++ b/libgfortran/generated/maxloc1_8_r16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_8_r16 (gfc_array_i8 * const restrict, 
-	gfc_array_r16 * const restrict, const index_type * const restrict);
+	gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_8_r16);
 
 void
 maxloc1_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_r16 (gfc_array_i8 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_8_r16);
 
 void
 mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_r16 (gfc_array_i8 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_8_r16);
 
 void
 smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_r16 (retarray, array, pdim, back);
+#else
       maxloc1_8_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c
index b97cd4c..5895585 100644
--- a/libgfortran/generated/maxloc1_8_r4.c
+++ b/libgfortran/generated/maxloc1_8_r4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_8_r4 (gfc_array_i8 * const restrict, 
-	gfc_array_r4 * const restrict, const index_type * const restrict);
+	gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_8_r4);
 
 void
 maxloc1_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_r4 (gfc_array_i8 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_8_r4);
 
 void
 mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_r4 (gfc_array_i8 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_8_r4);
 
 void
 smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_r4 (retarray, array, pdim, back);
+#else
       maxloc1_8_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c
index 69c0c29..8c79dd4 100644
--- a/libgfortran/generated/maxloc1_8_r8.c
+++ b/libgfortran/generated/maxloc1_8_r8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void maxloc1_8_r8 (gfc_array_i8 * const restrict, 
-	gfc_array_r8 * const restrict, const index_type * const restrict);
+	gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(maxloc1_8_r8);
 
 void
 maxloc1_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_r8 (gfc_array_i8 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mmaxloc1_8_r8);
 
 void
 mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_r8 (gfc_array_i8 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(smaxloc1_8_r8);
 
 void
 smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_r8 (retarray, array, pdim, back);
+#else
       maxloc1_8_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_s1.c b/libgfortran/generated/maxloc1_8_s1.c
index e18ec1a..aab2449 100644
--- a/libgfortran/generated/maxloc1_8_s1.c
+++ b/libgfortran/generated/maxloc1_8_s1.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void maxloc1_8_s1 (gfc_array_i8 * const restrict, 
-	gfc_array_s1 * const restrict, const index_type * const restrict,
+	gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(maxloc1_8_s1);
 
 void
 maxloc1_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ maxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ maxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_s1 (gfc_array_i8 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mmaxloc1_8_s1);
 
 void
 mmaxloc1_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mmaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mmaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_s1 (gfc_array_i8 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc1_8_s1);
 
 void
 smaxloc1_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ smaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_s1 (retarray, array, pdim, back, string_len);
+#else
       maxloc1_8_s1 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc1_8_s4.c b/libgfortran/generated/maxloc1_8_s4.c
index dbe40e9..f02e2a5 100644
--- a/libgfortran/generated/maxloc1_8_s4.c
+++ b/libgfortran/generated/maxloc1_8_s4.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void maxloc1_8_s4 (gfc_array_i8 * const restrict, 
-	gfc_array_s4 * const restrict, const index_type * const restrict,
+	gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(maxloc1_8_s4);
 
 void
 maxloc1_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ maxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ maxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
 
 extern void mmaxloc1_8_s4 (gfc_array_i8 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mmaxloc1_8_s4);
 
 void
 mmaxloc1_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mmaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mmaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
 
 extern void smaxloc1_8_s4 (gfc_array_i8 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc1_8_s4);
 
 void
 smaxloc1_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ smaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxloc1_8_s4 (retarray, array, pdim, back, string_len);
+#else
       maxloc1_8_s4 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxloc2_16_s1.c b/libgfortran/generated/maxloc2_16_s1.c
index 1a4a886..bfba707 100644
--- a/libgfortran/generated/maxloc2_16_s1.c
+++ b/libgfortran/generated/maxloc2_16_s1.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
@@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_16 maxloc2_16_s1 (gfc_array_s1 * const restrict,
+extern GFC_INTEGER_16 maxloc2_16_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
        gfc_charlen_type);
 export_proto(maxloc2_16_s1);
 
 GFC_INTEGER_16
-maxloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+maxloc2_16_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -52,6 +53,7 @@ maxloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_1 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -74,12 +76,13 @@ maxloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_16 mmaxloc2_16_s1 (gfc_array_s1 * const restrict,
-       		    	gfc_array_l1 *const restrict mask, gfc_charlen_type);
+       		    	gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+			gfc_charlen_type);
 export_proto(mmaxloc2_16_s1);
 
 GFC_INTEGER_16
 mmaxloc2_16_s1 (gfc_array_s1 * const restrict array,
-				 gfc_array_l1 * const restrict mask,
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
 				 gfc_charlen_type len)
 {
   index_type ret;
@@ -92,6 +95,7 @@ mmaxloc2_16_s1 (gfc_array_s1 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -141,15 +145,15 @@ mmaxloc2_16_s1 (gfc_array_s1 * const restrict array,
 }
 
 extern GFC_INTEGER_16 smaxloc2_16_s1 (gfc_array_s1 * const restrict,
-                               GFC_LOGICAL_4 *mask, gfc_charlen_type);
+                               GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc2_16_s1);
 
 GFC_INTEGER_16
 smaxloc2_16_s1 (gfc_array_s1 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return maxloc2_16_s1 (array, len);
+    return maxloc2_16_s1 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/maxloc2_16_s4.c b/libgfortran/generated/maxloc2_16_s4.c
index 31a6804..cf1235e 100644
--- a/libgfortran/generated/maxloc2_16_s4.c
+++ b/libgfortran/generated/maxloc2_16_s4.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
@@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_16 maxloc2_16_s4 (gfc_array_s4 * const restrict,
+extern GFC_INTEGER_16 maxloc2_16_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
        gfc_charlen_type);
 export_proto(maxloc2_16_s4);
 
 GFC_INTEGER_16
-maxloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+maxloc2_16_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -52,6 +53,7 @@ maxloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_4 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -74,12 +76,13 @@ maxloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_16 mmaxloc2_16_s4 (gfc_array_s4 * const restrict,
-       		    	gfc_array_l1 *const restrict mask, gfc_charlen_type);
+       		    	gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+			gfc_charlen_type);
 export_proto(mmaxloc2_16_s4);
 
 GFC_INTEGER_16
 mmaxloc2_16_s4 (gfc_array_s4 * const restrict array,
-				 gfc_array_l1 * const restrict mask,
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
 				 gfc_charlen_type len)
 {
   index_type ret;
@@ -92,6 +95,7 @@ mmaxloc2_16_s4 (gfc_array_s4 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -141,15 +145,15 @@ mmaxloc2_16_s4 (gfc_array_s4 * const restrict array,
 }
 
 extern GFC_INTEGER_16 smaxloc2_16_s4 (gfc_array_s4 * const restrict,
-                               GFC_LOGICAL_4 *mask, gfc_charlen_type);
+                               GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc2_16_s4);
 
 GFC_INTEGER_16
 smaxloc2_16_s4 (gfc_array_s4 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return maxloc2_16_s4 (array, len);
+    return maxloc2_16_s4 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/maxloc2_4_s1.c b/libgfortran/generated/maxloc2_4_s1.c
index e68f50a..e88ecca 100644
--- a/libgfortran/generated/maxloc2_4_s1.c
+++ b/libgfortran/generated/maxloc2_4_s1.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
@@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_4 maxloc2_4_s1 (gfc_array_s1 * const restrict,
+extern GFC_INTEGER_4 maxloc2_4_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
        gfc_charlen_type);
 export_proto(maxloc2_4_s1);
 
 GFC_INTEGER_4
-maxloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+maxloc2_4_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -52,6 +53,7 @@ maxloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_1 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -74,12 +76,13 @@ maxloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_4 mmaxloc2_4_s1 (gfc_array_s1 * const restrict,
-       		    	gfc_array_l1 *const restrict mask, gfc_charlen_type);
+       		    	gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+			gfc_charlen_type);
 export_proto(mmaxloc2_4_s1);
 
 GFC_INTEGER_4
 mmaxloc2_4_s1 (gfc_array_s1 * const restrict array,
-				 gfc_array_l1 * const restrict mask,
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
 				 gfc_charlen_type len)
 {
   index_type ret;
@@ -92,6 +95,7 @@ mmaxloc2_4_s1 (gfc_array_s1 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -141,15 +145,15 @@ mmaxloc2_4_s1 (gfc_array_s1 * const restrict array,
 }
 
 extern GFC_INTEGER_4 smaxloc2_4_s1 (gfc_array_s1 * const restrict,
-                               GFC_LOGICAL_4 *mask, gfc_charlen_type);
+                               GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc2_4_s1);
 
 GFC_INTEGER_4
 smaxloc2_4_s1 (gfc_array_s1 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return maxloc2_4_s1 (array, len);
+    return maxloc2_4_s1 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/maxloc2_4_s4.c b/libgfortran/generated/maxloc2_4_s4.c
index 104bfc6..adeba93 100644
--- a/libgfortran/generated/maxloc2_4_s4.c
+++ b/libgfortran/generated/maxloc2_4_s4.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
@@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_4 maxloc2_4_s4 (gfc_array_s4 * const restrict,
+extern GFC_INTEGER_4 maxloc2_4_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
        gfc_charlen_type);
 export_proto(maxloc2_4_s4);
 
 GFC_INTEGER_4
-maxloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+maxloc2_4_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -52,6 +53,7 @@ maxloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_4 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -74,12 +76,13 @@ maxloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_4 mmaxloc2_4_s4 (gfc_array_s4 * const restrict,
-       		    	gfc_array_l1 *const restrict mask, gfc_charlen_type);
+       		    	gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+			gfc_charlen_type);
 export_proto(mmaxloc2_4_s4);
 
 GFC_INTEGER_4
 mmaxloc2_4_s4 (gfc_array_s4 * const restrict array,
-				 gfc_array_l1 * const restrict mask,
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
 				 gfc_charlen_type len)
 {
   index_type ret;
@@ -92,6 +95,7 @@ mmaxloc2_4_s4 (gfc_array_s4 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -141,15 +145,15 @@ mmaxloc2_4_s4 (gfc_array_s4 * const restrict array,
 }
 
 extern GFC_INTEGER_4 smaxloc2_4_s4 (gfc_array_s4 * const restrict,
-                               GFC_LOGICAL_4 *mask, gfc_charlen_type);
+                               GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc2_4_s4);
 
 GFC_INTEGER_4
 smaxloc2_4_s4 (gfc_array_s4 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return maxloc2_4_s4 (array, len);
+    return maxloc2_4_s4 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/maxloc2_8_s1.c b/libgfortran/generated/maxloc2_8_s1.c
index 04c257ee..1a32e13 100644
--- a/libgfortran/generated/maxloc2_8_s1.c
+++ b/libgfortran/generated/maxloc2_8_s1.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
@@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_8 maxloc2_8_s1 (gfc_array_s1 * const restrict,
+extern GFC_INTEGER_8 maxloc2_8_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
        gfc_charlen_type);
 export_proto(maxloc2_8_s1);
 
 GFC_INTEGER_8
-maxloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+maxloc2_8_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -52,6 +53,7 @@ maxloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_1 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -74,12 +76,13 @@ maxloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_8 mmaxloc2_8_s1 (gfc_array_s1 * const restrict,
-       		    	gfc_array_l1 *const restrict mask, gfc_charlen_type);
+       		    	gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+			gfc_charlen_type);
 export_proto(mmaxloc2_8_s1);
 
 GFC_INTEGER_8
 mmaxloc2_8_s1 (gfc_array_s1 * const restrict array,
-				 gfc_array_l1 * const restrict mask,
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
 				 gfc_charlen_type len)
 {
   index_type ret;
@@ -92,6 +95,7 @@ mmaxloc2_8_s1 (gfc_array_s1 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -141,15 +145,15 @@ mmaxloc2_8_s1 (gfc_array_s1 * const restrict array,
 }
 
 extern GFC_INTEGER_8 smaxloc2_8_s1 (gfc_array_s1 * const restrict,
-                               GFC_LOGICAL_4 *mask, gfc_charlen_type);
+                               GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc2_8_s1);
 
 GFC_INTEGER_8
 smaxloc2_8_s1 (gfc_array_s1 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return maxloc2_8_s1 (array, len);
+    return maxloc2_8_s1 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/maxloc2_8_s4.c b/libgfortran/generated/maxloc2_8_s4.c
index fe7de50..ae22a51 100644
--- a/libgfortran/generated/maxloc2_8_s4.c
+++ b/libgfortran/generated/maxloc2_8_s4.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
@@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_8 maxloc2_8_s4 (gfc_array_s4 * const restrict,
+extern GFC_INTEGER_8 maxloc2_8_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
        gfc_charlen_type);
 export_proto(maxloc2_8_s4);
 
 GFC_INTEGER_8
-maxloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+maxloc2_8_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -52,6 +53,7 @@ maxloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_4 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -74,12 +76,13 @@ maxloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_8 mmaxloc2_8_s4 (gfc_array_s4 * const restrict,
-       		    	gfc_array_l1 *const restrict mask, gfc_charlen_type);
+       		    	gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+			gfc_charlen_type);
 export_proto(mmaxloc2_8_s4);
 
 GFC_INTEGER_8
 mmaxloc2_8_s4 (gfc_array_s4 * const restrict array,
-				 gfc_array_l1 * const restrict mask,
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
 				 gfc_charlen_type len)
 {
   index_type ret;
@@ -92,6 +95,7 @@ mmaxloc2_8_s4 (gfc_array_s4 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -141,15 +145,15 @@ mmaxloc2_8_s4 (gfc_array_s4 * const restrict array,
 }
 
 extern GFC_INTEGER_8 smaxloc2_8_s4 (gfc_array_s4 * const restrict,
-                               GFC_LOGICAL_4 *mask, gfc_charlen_type);
+                               GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(smaxloc2_8_s4);
 
 GFC_INTEGER_8
 smaxloc2_8_s4 (gfc_array_s4 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return maxloc2_8_s4 (array, len);
+    return maxloc2_8_s4 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c
index 88d80e1..2c6b865 100644
--- a/libgfortran/generated/maxval_i1.c
+++ b/libgfortran/generated/maxval_i1.c
@@ -51,6 +51,10 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxval_i1 (retarray, array, pdim, back);
+#else
       maxval_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c
index c555085..06046360 100644
--- a/libgfortran/generated/maxval_i16.c
+++ b/libgfortran/generated/maxval_i16.c
@@ -51,6 +51,10 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxval_i16 (retarray, array, pdim, back);
+#else
       maxval_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c
index 159ec96..bcd4343 100644
--- a/libgfortran/generated/maxval_i2.c
+++ b/libgfortran/generated/maxval_i2.c
@@ -51,6 +51,10 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxval_i2 (retarray, array, pdim, back);
+#else
       maxval_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c
index 70f8e90..bef1c29 100644
--- a/libgfortran/generated/maxval_i4.c
+++ b/libgfortran/generated/maxval_i4.c
@@ -51,6 +51,10 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxval_i4 (retarray, array, pdim, back);
+#else
       maxval_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c
index 49517bb..14deb70 100644
--- a/libgfortran/generated/maxval_i8.c
+++ b/libgfortran/generated/maxval_i8.c
@@ -51,6 +51,10 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxval_i8 (retarray, array, pdim, back);
+#else
       maxval_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c
index 683a6f9..85d6d83 100644
--- a/libgfortran/generated/maxval_r10.c
+++ b/libgfortran/generated/maxval_r10.c
@@ -51,6 +51,10 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxval_r10 (retarray, array, pdim, back);
+#else
       maxval_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c
index 1eaae8c..18ef367 100644
--- a/libgfortran/generated/maxval_r16.c
+++ b/libgfortran/generated/maxval_r16.c
@@ -51,6 +51,10 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxval_r16 (retarray, array, pdim, back);
+#else
       maxval_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c
index 72ac583..862fe63 100644
--- a/libgfortran/generated/maxval_r4.c
+++ b/libgfortran/generated/maxval_r4.c
@@ -51,6 +51,10 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxval_r4 (retarray, array, pdim, back);
+#else
       maxval_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c
index de58c87..9315483 100644
--- a/libgfortran/generated/maxval_r8.c
+++ b/libgfortran/generated/maxval_r8.c
@@ -51,6 +51,10 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      maxval_r8 (retarray, array, pdim, back);
+#else
       maxval_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c
index c958fdc..88720df 100644
--- a/libgfortran/generated/minloc0_16_i1.c
+++ b/libgfortran/generated/minloc0_16_i1.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void minloc0_16_i1 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i1 * const restrict array);
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_16_i1);
 
 void
 minloc0_16_i1 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i1 * const restrict array)
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_i1 (gfc_array_i16 * const restrict, 
-	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_16_i1);
 
 void
 mminloc0_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_i1 (gfc_array_i16 * const restrict, 
-	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_16_i1);
 
 void
 sminloc0_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_16_i1 (retarray, array);
+      minloc0_16_i1 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c
index 82c86b5..4e2b6d0 100644
--- a/libgfortran/generated/minloc0_16_i16.c
+++ b/libgfortran/generated/minloc0_16_i16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void minloc0_16_i16 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i16 * const restrict array);
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_16_i16);
 
 void
 minloc0_16_i16 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i16 * const restrict array)
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_i16 (gfc_array_i16 * const restrict, 
-	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_16_i16);
 
 void
 mminloc0_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_i16 (gfc_array_i16 * const restrict, 
-	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_16_i16);
 
 void
 sminloc0_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_16_i16 (retarray, array);
+      minloc0_16_i16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c
index b32d560..c9032c7 100644
--- a/libgfortran/generated/minloc0_16_i2.c
+++ b/libgfortran/generated/minloc0_16_i2.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void minloc0_16_i2 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i2 * const restrict array);
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_16_i2);
 
 void
 minloc0_16_i2 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i2 * const restrict array)
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_i2 (gfc_array_i16 * const restrict, 
-	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_16_i2);
 
 void
 mminloc0_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_i2 (gfc_array_i16 * const restrict, 
-	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_16_i2);
 
 void
 sminloc0_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_16_i2 (retarray, array);
+      minloc0_16_i2 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c
index 977bbb6..a27405a 100644
--- a/libgfortran/generated/minloc0_16_i4.c
+++ b/libgfortran/generated/minloc0_16_i4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void minloc0_16_i4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i4 * const restrict array);
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_16_i4);
 
 void
 minloc0_16_i4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i4 * const restrict array)
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_i4 (gfc_array_i16 * const restrict, 
-	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_16_i4);
 
 void
 mminloc0_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_i4 (gfc_array_i16 * const restrict, 
-	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_16_i4);
 
 void
 sminloc0_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_16_i4 (retarray, array);
+      minloc0_16_i4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c
index a55c97e..6874f66 100644
--- a/libgfortran/generated/minloc0_16_i8.c
+++ b/libgfortran/generated/minloc0_16_i8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void minloc0_16_i8 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i8 * const restrict array);
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_16_i8);
 
 void
 minloc0_16_i8 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_i8 * const restrict array)
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_i8 (gfc_array_i16 * const restrict, 
-	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_16_i8);
 
 void
 mminloc0_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_i8 (gfc_array_i16 * const restrict, 
-	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_16_i8);
 
 void
 sminloc0_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_16_i8 (retarray, array);
+      minloc0_16_i8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c
index 594e433..ad97459 100644
--- a/libgfortran/generated/minloc0_16_r10.c
+++ b/libgfortran/generated/minloc0_16_r10.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void minloc0_16_r10 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r10 * const restrict array);
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_16_r10);
 
 void
 minloc0_16_r10 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r10 * const restrict array)
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_r10 (gfc_array_i16 * const restrict, 
-	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_16_r10);
 
 void
 mminloc0_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_r10 (gfc_array_i16 * const restrict, 
-	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_16_r10);
 
 void
 sminloc0_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_16_r10 (retarray, array);
+      minloc0_16_r10 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c
index 22bf131..f8245ed 100644
--- a/libgfortran/generated/minloc0_16_r16.c
+++ b/libgfortran/generated/minloc0_16_r16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void minloc0_16_r16 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r16 * const restrict array);
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_16_r16);
 
 void
 minloc0_16_r16 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r16 * const restrict array)
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_r16 (gfc_array_i16 * const restrict, 
-	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_16_r16);
 
 void
 mminloc0_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_r16 (gfc_array_i16 * const restrict, 
-	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_16_r16);
 
 void
 sminloc0_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_16_r16 (retarray, array);
+      minloc0_16_r16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c
index f7b8e9e..ed41783 100644
--- a/libgfortran/generated/minloc0_16_r4.c
+++ b/libgfortran/generated/minloc0_16_r4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void minloc0_16_r4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r4 * const restrict array);
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_16_r4);
 
 void
 minloc0_16_r4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r4 * const restrict array)
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_r4 (gfc_array_i16 * const restrict, 
-	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_16_r4);
 
 void
 mminloc0_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_r4 (gfc_array_i16 * const restrict, 
-	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_16_r4);
 
 void
 sminloc0_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_16_r4 (retarray, array);
+      minloc0_16_r4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c
index 3be2ea9..0799d4d 100644
--- a/libgfortran/generated/minloc0_16_r8.c
+++ b/libgfortran/generated/minloc0_16_r8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_16)
 
 
 extern void minloc0_16_r8 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r8 * const restrict array);
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_16_r8);
 
 void
 minloc0_16_r8 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_r8 * const restrict array)
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_r8 (gfc_array_i16 * const restrict, 
-	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_16_r8);
 
 void
 mminloc0_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_r8 (gfc_array_i16 * const restrict, 
-	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_16_r8);
 
 void
 sminloc0_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_16_r8 (retarray, array);
+      minloc0_16_r8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_s1.c b/libgfortran/generated/minloc0_16_s1.c
index 524d27d..e566d74 100644
--- a/libgfortran/generated/minloc0_16_s1.c
+++ b/libgfortran/generated/minloc0_16_s1.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void minloc0_16_s1 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len);
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(minloc0_16_s1);
 
 void
 minloc0_16_s1 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len)
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ minloc0_16_s1 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ minloc0_16_s1 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_s1 (gfc_array_i16 * const restrict, 
-	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mminloc0_16_s1);
 
 void
 mminloc0_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mminloc0_16_s1 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mminloc0_16_s1 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_s1 (gfc_array_i16 * const restrict, 
-	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(sminloc0_16_s1);
 
 void
 sminloc0_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ sminloc0_16_s1 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      minloc0_16_s1 (retarray, array, back, len);
+#else
       minloc0_16_s1 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_16_s4.c b/libgfortran/generated/minloc0_16_s4.c
index 736eaa3..2a0b13c 100644
--- a/libgfortran/generated/minloc0_16_s4.c
+++ b/libgfortran/generated/minloc0_16_s4.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void minloc0_16_s4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len);
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(minloc0_16_s4);
 
 void
 minloc0_16_s4 (gfc_array_i16 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len)
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ minloc0_16_s4 (gfc_array_i16 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ minloc0_16_s4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void mminloc0_16_s4 (gfc_array_i16 * const restrict, 
-	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mminloc0_16_s4);
 
 void
 mminloc0_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mminloc0_16_s4 (gfc_array_i16 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mminloc0_16_s4 (gfc_array_i16 * const restrict retarray,
 
 
 extern void sminloc0_16_s4 (gfc_array_i16 * const restrict, 
-	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(sminloc0_16_s4);
 
 void
 sminloc0_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ sminloc0_16_s4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      minloc0_16_s4 (retarray, array, back, len);
+#else
       minloc0_16_s4 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c
index acfbb91..577c9dd 100644
--- a/libgfortran/generated/minloc0_4_i1.c
+++ b/libgfortran/generated/minloc0_4_i1.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void minloc0_4_i1 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i1 * const restrict array);
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_4_i1);
 
 void
 minloc0_4_i1 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i1 * const restrict array)
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_i1 (gfc_array_i4 * const restrict, 
-	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_4_i1);
 
 void
 mminloc0_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_i1 (gfc_array_i4 * const restrict, 
-	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_4_i1);
 
 void
 sminloc0_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_4_i1 (retarray, array);
+      minloc0_4_i1 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c
index a47b20e..48da69e 100644
--- a/libgfortran/generated/minloc0_4_i16.c
+++ b/libgfortran/generated/minloc0_4_i16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void minloc0_4_i16 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i16 * const restrict array);
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_4_i16);
 
 void
 minloc0_4_i16 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i16 * const restrict array)
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_i16 (gfc_array_i4 * const restrict, 
-	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_4_i16);
 
 void
 mminloc0_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_i16 (gfc_array_i4 * const restrict, 
-	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_4_i16);
 
 void
 sminloc0_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_4_i16 (retarray, array);
+      minloc0_4_i16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c
index 8b378ba..815ea85 100644
--- a/libgfortran/generated/minloc0_4_i2.c
+++ b/libgfortran/generated/minloc0_4_i2.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void minloc0_4_i2 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i2 * const restrict array);
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_4_i2);
 
 void
 minloc0_4_i2 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i2 * const restrict array)
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_i2 (gfc_array_i4 * const restrict, 
-	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_4_i2);
 
 void
 mminloc0_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_i2 (gfc_array_i4 * const restrict, 
-	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_4_i2);
 
 void
 sminloc0_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_4_i2 (retarray, array);
+      minloc0_4_i2 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c
index b91d2bf..36b0a58 100644
--- a/libgfortran/generated/minloc0_4_i4.c
+++ b/libgfortran/generated/minloc0_4_i4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void minloc0_4_i4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i4 * const restrict array);
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_4_i4);
 
 void
 minloc0_4_i4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i4 * const restrict array)
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_i4 (gfc_array_i4 * const restrict, 
-	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_4_i4);
 
 void
 mminloc0_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_i4 (gfc_array_i4 * const restrict, 
-	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_4_i4);
 
 void
 sminloc0_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_4_i4 (retarray, array);
+      minloc0_4_i4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c
index ee87eaa..a66280c 100644
--- a/libgfortran/generated/minloc0_4_i8.c
+++ b/libgfortran/generated/minloc0_4_i8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void minloc0_4_i8 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i8 * const restrict array);
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_4_i8);
 
 void
 minloc0_4_i8 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_i8 * const restrict array)
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_i8 (gfc_array_i4 * const restrict, 
-	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_4_i8);
 
 void
 mminloc0_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_i8 (gfc_array_i4 * const restrict, 
-	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_4_i8);
 
 void
 sminloc0_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_4_i8 (retarray, array);
+      minloc0_4_i8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c
index 9d39606..461ad0d 100644
--- a/libgfortran/generated/minloc0_4_r10.c
+++ b/libgfortran/generated/minloc0_4_r10.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void minloc0_4_r10 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r10 * const restrict array);
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_4_r10);
 
 void
 minloc0_4_r10 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r10 * const restrict array)
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_r10 (gfc_array_i4 * const restrict, 
-	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_4_r10);
 
 void
 mminloc0_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_r10 (gfc_array_i4 * const restrict, 
-	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_4_r10);
 
 void
 sminloc0_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_4_r10 (retarray, array);
+      minloc0_4_r10 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c
index be920c3..27e6d1d 100644
--- a/libgfortran/generated/minloc0_4_r16.c
+++ b/libgfortran/generated/minloc0_4_r16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void minloc0_4_r16 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r16 * const restrict array);
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_4_r16);
 
 void
 minloc0_4_r16 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r16 * const restrict array)
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_r16 (gfc_array_i4 * const restrict, 
-	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_4_r16);
 
 void
 mminloc0_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_r16 (gfc_array_i4 * const restrict, 
-	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_4_r16);
 
 void
 sminloc0_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_4_r16 (retarray, array);
+      minloc0_4_r16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c
index f5beb64..1b85544 100644
--- a/libgfortran/generated/minloc0_4_r4.c
+++ b/libgfortran/generated/minloc0_4_r4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void minloc0_4_r4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r4 * const restrict array);
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_4_r4);
 
 void
 minloc0_4_r4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r4 * const restrict array)
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_r4 (gfc_array_i4 * const restrict, 
-	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_4_r4);
 
 void
 mminloc0_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_r4 (gfc_array_i4 * const restrict, 
-	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_4_r4);
 
 void
 sminloc0_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_4_r4 (retarray, array);
+      minloc0_4_r4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c
index 2f6973c..7c6d6bfb 100644
--- a/libgfortran/generated/minloc0_4_r8.c
+++ b/libgfortran/generated/minloc0_4_r8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_4)
 
 
 extern void minloc0_4_r8 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r8 * const restrict array);
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_4_r8);
 
 void
 minloc0_4_r8 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_r8 * const restrict array)
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_r8 (gfc_array_i4 * const restrict, 
-	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_4_r8);
 
 void
 mminloc0_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_r8 (gfc_array_i4 * const restrict, 
-	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_4_r8);
 
 void
 sminloc0_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_4_r8 (retarray, array);
+      minloc0_4_r8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_s1.c b/libgfortran/generated/minloc0_4_s1.c
index 111ee09..4d58df4 100644
--- a/libgfortran/generated/minloc0_4_s1.c
+++ b/libgfortran/generated/minloc0_4_s1.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void minloc0_4_s1 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len);
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(minloc0_4_s1);
 
 void
 minloc0_4_s1 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len)
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ minloc0_4_s1 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ minloc0_4_s1 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_s1 (gfc_array_i4 * const restrict, 
-	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mminloc0_4_s1);
 
 void
 mminloc0_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mminloc0_4_s1 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mminloc0_4_s1 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_s1 (gfc_array_i4 * const restrict, 
-	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(sminloc0_4_s1);
 
 void
 sminloc0_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ sminloc0_4_s1 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      minloc0_4_s1 (retarray, array, back, len);
+#else
       minloc0_4_s1 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_4_s4.c b/libgfortran/generated/minloc0_4_s4.c
index d5379df..bea56c0 100644
--- a/libgfortran/generated/minloc0_4_s4.c
+++ b/libgfortran/generated/minloc0_4_s4.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void minloc0_4_s4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len);
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(minloc0_4_s4);
 
 void
 minloc0_4_s4 (gfc_array_i4 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len)
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ minloc0_4_s4 (gfc_array_i4 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ minloc0_4_s4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void mminloc0_4_s4 (gfc_array_i4 * const restrict, 
-	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mminloc0_4_s4);
 
 void
 mminloc0_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mminloc0_4_s4 (gfc_array_i4 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mminloc0_4_s4 (gfc_array_i4 * const restrict retarray,
 
 
 extern void sminloc0_4_s4 (gfc_array_i4 * const restrict, 
-	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(sminloc0_4_s4);
 
 void
 sminloc0_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ sminloc0_4_s4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      minloc0_4_s4 (retarray, array, back, len);
+#else
       minloc0_4_s4 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c
index cf7f5c1..b0bccc8 100644
--- a/libgfortran/generated/minloc0_8_i1.c
+++ b/libgfortran/generated/minloc0_8_i1.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void minloc0_8_i1 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i1 * const restrict array);
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_8_i1);
 
 void
 minloc0_8_i1 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i1 * const restrict array)
+	gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_i1 (gfc_array_i8 * const restrict, 
-	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_8_i1);
 
 void
 mminloc0_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_i1 (gfc_array_i8 * const restrict, 
-	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_8_i1);
 
 void
 sminloc0_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_8_i1 (retarray, array);
+      minloc0_8_i1 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c
index d703408f..b4fb041 100644
--- a/libgfortran/generated/minloc0_8_i16.c
+++ b/libgfortran/generated/minloc0_8_i16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void minloc0_8_i16 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i16 * const restrict array);
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_8_i16);
 
 void
 minloc0_8_i16 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i16 * const restrict array)
+	gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_i16 (gfc_array_i8 * const restrict, 
-	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_8_i16);
 
 void
 mminloc0_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_i16 (gfc_array_i8 * const restrict, 
-	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_8_i16);
 
 void
 sminloc0_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_8_i16 (retarray, array);
+      minloc0_8_i16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c
index 003c33b..13b3904 100644
--- a/libgfortran/generated/minloc0_8_i2.c
+++ b/libgfortran/generated/minloc0_8_i2.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void minloc0_8_i2 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i2 * const restrict array);
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_8_i2);
 
 void
 minloc0_8_i2 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i2 * const restrict array)
+	gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_i2 (gfc_array_i8 * const restrict, 
-	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_8_i2);
 
 void
 mminloc0_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_i2 (gfc_array_i8 * const restrict, 
-	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_8_i2);
 
 void
 sminloc0_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_8_i2 (retarray, array);
+      minloc0_8_i2 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c
index 4b2f245..5d4dc06 100644
--- a/libgfortran/generated/minloc0_8_i4.c
+++ b/libgfortran/generated/minloc0_8_i4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void minloc0_8_i4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i4 * const restrict array);
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_8_i4);
 
 void
 minloc0_8_i4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i4 * const restrict array)
+	gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_i4 (gfc_array_i8 * const restrict, 
-	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_8_i4);
 
 void
 mminloc0_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_i4 (gfc_array_i8 * const restrict, 
-	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_8_i4);
 
 void
 sminloc0_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_8_i4 (retarray, array);
+      minloc0_8_i4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c
index 6f2dc2e..d4cf9a4 100644
--- a/libgfortran/generated/minloc0_8_i8.c
+++ b/libgfortran/generated/minloc0_8_i8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void minloc0_8_i8 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i8 * const restrict array);
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_8_i8);
 
 void
 minloc0_8_i8 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_i8 * const restrict array)
+	gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_i8 (gfc_array_i8 * const restrict, 
-	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_8_i8);
 
 void
 mminloc0_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_i8 (gfc_array_i8 * const restrict, 
-	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_8_i8);
 
 void
 sminloc0_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_8_i8 (retarray, array);
+      minloc0_8_i8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c
index 1f08628..c74fe0f 100644
--- a/libgfortran/generated/minloc0_8_r10.c
+++ b/libgfortran/generated/minloc0_8_r10.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void minloc0_8_r10 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r10 * const restrict array);
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_8_r10);
 
 void
 minloc0_8_r10 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r10 * const restrict array)
+	gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_r10 (gfc_array_i8 * const restrict, 
-	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_8_r10);
 
 void
 mminloc0_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_r10 (gfc_array_i8 * const restrict, 
-	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_8_r10);
 
 void
 sminloc0_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_8_r10 (retarray, array);
+      minloc0_8_r10 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c
index e32fd13..0ce3fd7 100644
--- a/libgfortran/generated/minloc0_8_r16.c
+++ b/libgfortran/generated/minloc0_8_r16.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void minloc0_8_r16 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r16 * const restrict array);
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_8_r16);
 
 void
 minloc0_8_r16 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r16 * const restrict array)
+	gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_r16 (gfc_array_i8 * const restrict, 
-	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_8_r16);
 
 void
 mminloc0_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_r16 (gfc_array_i8 * const restrict, 
-	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_8_r16);
 
 void
 sminloc0_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_8_r16 (retarray, array);
+      minloc0_8_r16 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c
index 533e748..66c5b74 100644
--- a/libgfortran/generated/minloc0_8_r4.c
+++ b/libgfortran/generated/minloc0_8_r4.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void minloc0_8_r4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r4 * const restrict array);
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_8_r4);
 
 void
 minloc0_8_r4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r4 * const restrict array)
+	gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_r4 (gfc_array_i8 * const restrict, 
-	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_8_r4);
 
 void
 mminloc0_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_r4 (gfc_array_i8 * const restrict, 
-	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_8_r4);
 
 void
 sminloc0_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_8_r4 (retarray, array);
+      minloc0_8_r4 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c
index 1eb7423..bd6b217 100644
--- a/libgfortran/generated/minloc0_8_r8.c
+++ b/libgfortran/generated/minloc0_8_r8.c
@@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_8)
 
 
 extern void minloc0_8_r8 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r8 * const restrict array);
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
 export_proto(minloc0_8_r8);
 
 void
 minloc0_8_r8 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_r8 * const restrict array)
+	gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -46,6 +47,7 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -167,13 +169,14 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_r8 (gfc_array_i8 * const restrict, 
-	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+	gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(mminloc0_8_r8);
 
 void
 mminloc0_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -187,6 +190,7 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -335,13 +339,13 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_r8 (gfc_array_i8 * const restrict, 
-	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+	gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(sminloc0_8_r8);
 
 void
 sminloc0_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -350,7 +354,7 @@ sminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
-      minloc0_8_r8 (retarray, array);
+      minloc0_8_r8 (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_s1.c b/libgfortran/generated/minloc0_8_s1.c
index d7b6bee..dd9be96 100644
--- a/libgfortran/generated/minloc0_8_s1.c
+++ b/libgfortran/generated/minloc0_8_s1.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void minloc0_8_s1 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len);
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(minloc0_8_s1);
 
 void
 minloc0_8_s1 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_s1 * const restrict array, gfc_charlen_type len)
+	gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ minloc0_8_s1 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ minloc0_8_s1 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_s1 (gfc_array_i8 * const restrict, 
-	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mminloc0_8_s1);
 
 void
 mminloc0_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mminloc0_8_s1 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mminloc0_8_s1 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_s1 (gfc_array_i8 * const restrict, 
-	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(sminloc0_8_s1);
 
 void
 sminloc0_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ sminloc0_8_s1 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      minloc0_8_s1 (retarray, array, back, len);
+#else
       minloc0_8_s1 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/minloc0_8_s4.c b/libgfortran/generated/minloc0_8_s4.c
index ca1910c..46d29ec 100644
--- a/libgfortran/generated/minloc0_8_s4.c
+++ b/libgfortran/generated/minloc0_8_s4.c
@@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 {
@@ -43,12 +45,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void minloc0_8_s4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len);
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
 export_proto(minloc0_8_s4);
 
 void
 minloc0_8_s4 (gfc_array_i8 * const restrict retarray, 
-	gfc_array_s4 * const restrict array, gfc_charlen_type len)
+	gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -59,6 +61,10 @@ minloc0_8_s4 (gfc_array_i8 * const restrict retarray,
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -149,13 +155,15 @@ minloc0_8_s4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void mminloc0_8_s4 (gfc_array_i8 * const restrict, 
-	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(mminloc0_8_s4);
 
 void
 mminloc0_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -169,6 +177,9 @@ mminloc0_8_s4 (gfc_array_i8 * const restrict retarray,
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -282,13 +293,15 @@ mminloc0_8_s4 (gfc_array_i8 * const restrict retarray,
 
 
 extern void sminloc0_8_s4 (gfc_array_i8 * const restrict, 
-	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+	gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+	gfc_charlen_type len);
 export_proto(sminloc0_8_s4);
 
 void
 sminloc0_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
@@ -297,7 +310,11 @@ sminloc0_8_s4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      minloc0_8_s4 (retarray, array, back, len);
+#else
       minloc0_8_s4 (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c
index e03ea37..20197c4 100644
--- a/libgfortran/generated/minloc1_16_i1.c
+++ b/libgfortran/generated/minloc1_16_i1.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_16_i1 (gfc_array_i16 * const restrict, 
-	gfc_array_i1 * const restrict, const index_type * const restrict);
+	gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_16_i1);
 
 void
 minloc1_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_i1 (gfc_array_i16 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_16_i1);
 
 void
 mminloc1_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_i1 (gfc_array_i16 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_16_i1);
 
 void
 sminloc1_16_i1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_i1 (retarray, array, pdim, back);
+#else
       minloc1_16_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c
index 0ef0bda..fc718a8 100644
--- a/libgfortran/generated/minloc1_16_i16.c
+++ b/libgfortran/generated/minloc1_16_i16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_16_i16 (gfc_array_i16 * const restrict, 
-	gfc_array_i16 * const restrict, const index_type * const restrict);
+	gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_16_i16);
 
 void
 minloc1_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_i16 (gfc_array_i16 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_16_i16);
 
 void
 mminloc1_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_i16 (gfc_array_i16 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_16_i16);
 
 void
 sminloc1_16_i16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_i16 (retarray, array, pdim, back);
+#else
       minloc1_16_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c
index df854ce..e9352b1 100644
--- a/libgfortran/generated/minloc1_16_i2.c
+++ b/libgfortran/generated/minloc1_16_i2.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_16_i2 (gfc_array_i16 * const restrict, 
-	gfc_array_i2 * const restrict, const index_type * const restrict);
+	gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_16_i2);
 
 void
 minloc1_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_i2 (gfc_array_i16 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_16_i2);
 
 void
 mminloc1_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_i2 (gfc_array_i16 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_16_i2);
 
 void
 sminloc1_16_i2 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_i2 (retarray, array, pdim, back);
+#else
       minloc1_16_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c
index 8c02e7a..9faa5b3 100644
--- a/libgfortran/generated/minloc1_16_i4.c
+++ b/libgfortran/generated/minloc1_16_i4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_16_i4 (gfc_array_i16 * const restrict, 
-	gfc_array_i4 * const restrict, const index_type * const restrict);
+	gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_16_i4);
 
 void
 minloc1_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_i4 (gfc_array_i16 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_16_i4);
 
 void
 mminloc1_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_i4 (gfc_array_i16 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_16_i4);
 
 void
 sminloc1_16_i4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_i4 (retarray, array, pdim, back);
+#else
       minloc1_16_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c
index 938da8d..6ad4abe 100644
--- a/libgfortran/generated/minloc1_16_i8.c
+++ b/libgfortran/generated/minloc1_16_i8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_16_i8 (gfc_array_i16 * const restrict, 
-	gfc_array_i8 * const restrict, const index_type * const restrict);
+	gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_16_i8);
 
 void
 minloc1_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_i8 (gfc_array_i16 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_16_i8);
 
 void
 mminloc1_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_i8 (gfc_array_i16 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_16_i8);
 
 void
 sminloc1_16_i8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_i8 (retarray, array, pdim, back);
+#else
       minloc1_16_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c
index fbbcce6..930d077 100644
--- a/libgfortran/generated/minloc1_16_r10.c
+++ b/libgfortran/generated/minloc1_16_r10.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_16_r10 (gfc_array_i16 * const restrict, 
-	gfc_array_r10 * const restrict, const index_type * const restrict);
+	gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_16_r10);
 
 void
 minloc1_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_r10 (gfc_array_i16 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_16_r10);
 
 void
 mminloc1_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_r10 (gfc_array_i16 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_16_r10);
 
 void
 sminloc1_16_r10 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_r10 (retarray, array, pdim, back);
+#else
       minloc1_16_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c
index 4d3df6c..2003d8f 100644
--- a/libgfortran/generated/minloc1_16_r16.c
+++ b/libgfortran/generated/minloc1_16_r16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_16_r16 (gfc_array_i16 * const restrict, 
-	gfc_array_r16 * const restrict, const index_type * const restrict);
+	gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_16_r16);
 
 void
 minloc1_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_r16 (gfc_array_i16 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_16_r16);
 
 void
 mminloc1_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_r16 (gfc_array_i16 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_16_r16);
 
 void
 sminloc1_16_r16 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_r16 (retarray, array, pdim, back);
+#else
       minloc1_16_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c
index ff62be4..7b96983 100644
--- a/libgfortran/generated/minloc1_16_r4.c
+++ b/libgfortran/generated/minloc1_16_r4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_16_r4 (gfc_array_i16 * const restrict, 
-	gfc_array_r4 * const restrict, const index_type * const restrict);
+	gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_16_r4);
 
 void
 minloc1_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_r4 (gfc_array_i16 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_16_r4);
 
 void
 mminloc1_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_r4 (gfc_array_i16 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_16_r4);
 
 void
 sminloc1_16_r4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_r4 (retarray, array, pdim, back);
+#else
       minloc1_16_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c
index 51ea636..d683915 100644
--- a/libgfortran/generated/minloc1_16_r8.c
+++ b/libgfortran/generated/minloc1_16_r8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_16_r8 (gfc_array_i16 * const restrict, 
-	gfc_array_r8 * const restrict, const index_type * const restrict);
+	gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_16_r8);
 
 void
 minloc1_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_r8 (gfc_array_i16 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_16_r8);
 
 void
 mminloc1_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_r8 (gfc_array_i16 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_16_r8);
 
 void
 sminloc1_16_r8 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_r8 (retarray, array, pdim, back);
+#else
       minloc1_16_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_s1.c b/libgfortran/generated/minloc1_16_s1.c
index 51d49c2..898d124 100644
--- a/libgfortran/generated/minloc1_16_s1.c
+++ b/libgfortran/generated/minloc1_16_s1.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void minloc1_16_s1 (gfc_array_i16 * const restrict, 
-	gfc_array_s1 * const restrict, const index_type * const restrict,
+	gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(minloc1_16_s1);
 
 void
 minloc1_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ minloc1_16_s1 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ minloc1_16_s1 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_s1 (gfc_array_i16 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mminloc1_16_s1);
 
 void
 mminloc1_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mminloc1_16_s1 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mminloc1_16_s1 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_s1 (gfc_array_i16 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc1_16_s1);
 
 void
 sminloc1_16_s1 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ sminloc1_16_s1 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_s1 (retarray, array, pdim, back, string_len);
+#else
       minloc1_16_s1 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_16_s4.c b/libgfortran/generated/minloc1_16_s4.c
index cebf6b3..82eb258 100644
--- a/libgfortran/generated/minloc1_16_s4.c
+++ b/libgfortran/generated/minloc1_16_s4.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void minloc1_16_s4 (gfc_array_i16 * const restrict, 
-	gfc_array_s4 * const restrict, const index_type * const restrict,
+	gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(minloc1_16_s4);
 
 void
 minloc1_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ minloc1_16_s4 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ minloc1_16_s4 (gfc_array_i16 * const restrict retarray,
 
 extern void mminloc1_16_s4 (gfc_array_i16 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mminloc1_16_s4);
 
 void
 mminloc1_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mminloc1_16_s4 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mminloc1_16_s4 (gfc_array_i16 * const restrict retarray,
 
 extern void sminloc1_16_s4 (gfc_array_i16 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc1_16_s4);
 
 void
 sminloc1_16_s4 (gfc_array_i16 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ sminloc1_16_s4 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_16_s4 (retarray, array, pdim, back, string_len);
+#else
       minloc1_16_s4 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c
index e961877..b36f268 100644
--- a/libgfortran/generated/minloc1_4_i1.c
+++ b/libgfortran/generated/minloc1_4_i1.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_4_i1 (gfc_array_i4 * const restrict, 
-	gfc_array_i1 * const restrict, const index_type * const restrict);
+	gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_4_i1);
 
 void
 minloc1_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_i1 (gfc_array_i4 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_4_i1);
 
 void
 mminloc1_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_i1 (gfc_array_i4 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_4_i1);
 
 void
 sminloc1_4_i1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_i1 (retarray, array, pdim, back);
+#else
       minloc1_4_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c
index 3ea294e..b4454e1 100644
--- a/libgfortran/generated/minloc1_4_i16.c
+++ b/libgfortran/generated/minloc1_4_i16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_4_i16 (gfc_array_i4 * const restrict, 
-	gfc_array_i16 * const restrict, const index_type * const restrict);
+	gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_4_i16);
 
 void
 minloc1_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_i16 (gfc_array_i4 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_4_i16);
 
 void
 mminloc1_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_i16 (gfc_array_i4 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_4_i16);
 
 void
 sminloc1_4_i16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_i16 (retarray, array, pdim, back);
+#else
       minloc1_4_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c
index 564c262..f8ab77c 100644
--- a/libgfortran/generated/minloc1_4_i2.c
+++ b/libgfortran/generated/minloc1_4_i2.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_4_i2 (gfc_array_i4 * const restrict, 
-	gfc_array_i2 * const restrict, const index_type * const restrict);
+	gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_4_i2);
 
 void
 minloc1_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_i2 (gfc_array_i4 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_4_i2);
 
 void
 mminloc1_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_i2 (gfc_array_i4 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_4_i2);
 
 void
 sminloc1_4_i2 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_i2 (retarray, array, pdim, back);
+#else
       minloc1_4_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c
index 97dd9c2..6523d01 100644
--- a/libgfortran/generated/minloc1_4_i4.c
+++ b/libgfortran/generated/minloc1_4_i4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_4_i4 (gfc_array_i4 * const restrict, 
-	gfc_array_i4 * const restrict, const index_type * const restrict);
+	gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_4_i4);
 
 void
 minloc1_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_i4 (gfc_array_i4 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_4_i4);
 
 void
 mminloc1_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_i4 (gfc_array_i4 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_4_i4);
 
 void
 sminloc1_4_i4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_i4 (retarray, array, pdim, back);
+#else
       minloc1_4_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c
index 4c40632..ab1b6ba 100644
--- a/libgfortran/generated/minloc1_4_i8.c
+++ b/libgfortran/generated/minloc1_4_i8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_4_i8 (gfc_array_i4 * const restrict, 
-	gfc_array_i8 * const restrict, const index_type * const restrict);
+	gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_4_i8);
 
 void
 minloc1_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_i8 (gfc_array_i4 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_4_i8);
 
 void
 mminloc1_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_i8 (gfc_array_i4 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_4_i8);
 
 void
 sminloc1_4_i8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_i8 (retarray, array, pdim, back);
+#else
       minloc1_4_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c
index 01903a79..a481ec4 100644
--- a/libgfortran/generated/minloc1_4_r10.c
+++ b/libgfortran/generated/minloc1_4_r10.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_4_r10 (gfc_array_i4 * const restrict, 
-	gfc_array_r10 * const restrict, const index_type * const restrict);
+	gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_4_r10);
 
 void
 minloc1_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_r10 (gfc_array_i4 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_4_r10);
 
 void
 mminloc1_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_r10 (gfc_array_i4 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_4_r10);
 
 void
 sminloc1_4_r10 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_r10 (retarray, array, pdim, back);
+#else
       minloc1_4_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c
index f266ea7..f5fcb66 100644
--- a/libgfortran/generated/minloc1_4_r16.c
+++ b/libgfortran/generated/minloc1_4_r16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_4_r16 (gfc_array_i4 * const restrict, 
-	gfc_array_r16 * const restrict, const index_type * const restrict);
+	gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_4_r16);
 
 void
 minloc1_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_r16 (gfc_array_i4 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_4_r16);
 
 void
 mminloc1_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_r16 (gfc_array_i4 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_4_r16);
 
 void
 sminloc1_4_r16 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_r16 (retarray, array, pdim, back);
+#else
       minloc1_4_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c
index 3f680e5..212aa25 100644
--- a/libgfortran/generated/minloc1_4_r4.c
+++ b/libgfortran/generated/minloc1_4_r4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_4_r4 (gfc_array_i4 * const restrict, 
-	gfc_array_r4 * const restrict, const index_type * const restrict);
+	gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_4_r4);
 
 void
 minloc1_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_r4 (gfc_array_i4 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_4_r4);
 
 void
 mminloc1_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_r4 (gfc_array_i4 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_4_r4);
 
 void
 sminloc1_4_r4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_r4 (retarray, array, pdim, back);
+#else
       minloc1_4_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c
index dc425ef..1fa41f2 100644
--- a/libgfortran/generated/minloc1_4_r8.c
+++ b/libgfortran/generated/minloc1_4_r8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_4_r8 (gfc_array_i4 * const restrict, 
-	gfc_array_r8 * const restrict, const index_type * const restrict);
+	gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_4_r8);
 
 void
 minloc1_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_r8 (gfc_array_i4 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_4_r8);
 
 void
 mminloc1_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_r8 (gfc_array_i4 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_4_r8);
 
 void
 sminloc1_4_r8 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_r8 (retarray, array, pdim, back);
+#else
       minloc1_4_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_s1.c b/libgfortran/generated/minloc1_4_s1.c
index 0b8c0e8..1b7e551 100644
--- a/libgfortran/generated/minloc1_4_s1.c
+++ b/libgfortran/generated/minloc1_4_s1.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void minloc1_4_s1 (gfc_array_i4 * const restrict, 
-	gfc_array_s1 * const restrict, const index_type * const restrict,
+	gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(minloc1_4_s1);
 
 void
 minloc1_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ minloc1_4_s1 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ minloc1_4_s1 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_s1 (gfc_array_i4 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mminloc1_4_s1);
 
 void
 mminloc1_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mminloc1_4_s1 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mminloc1_4_s1 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_s1 (gfc_array_i4 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc1_4_s1);
 
 void
 sminloc1_4_s1 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ sminloc1_4_s1 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_s1 (retarray, array, pdim, back, string_len);
+#else
       minloc1_4_s1 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_4_s4.c b/libgfortran/generated/minloc1_4_s4.c
index c92f690..b3c6010 100644
--- a/libgfortran/generated/minloc1_4_s4.c
+++ b/libgfortran/generated/minloc1_4_s4.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void minloc1_4_s4 (gfc_array_i4 * const restrict, 
-	gfc_array_s4 * const restrict, const index_type * const restrict,
+	gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(minloc1_4_s4);
 
 void
 minloc1_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ minloc1_4_s4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ minloc1_4_s4 (gfc_array_i4 * const restrict retarray,
 
 extern void mminloc1_4_s4 (gfc_array_i4 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mminloc1_4_s4);
 
 void
 mminloc1_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mminloc1_4_s4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mminloc1_4_s4 (gfc_array_i4 * const restrict retarray,
 
 extern void sminloc1_4_s4 (gfc_array_i4 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc1_4_s4);
 
 void
 sminloc1_4_s4 (gfc_array_i4 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ sminloc1_4_s4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_4_s4 (retarray, array, pdim, back, string_len);
+#else
       minloc1_4_s4 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c
index 913a7a6..66771b3 100644
--- a/libgfortran/generated/minloc1_8_i1.c
+++ b/libgfortran/generated/minloc1_8_i1.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_8_i1 (gfc_array_i8 * const restrict, 
-	gfc_array_i1 * const restrict, const index_type * const restrict);
+	gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_8_i1);
 
 void
 minloc1_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_i1 (gfc_array_i8 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_8_i1);
 
 void
 mminloc1_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_i1 (gfc_array_i8 * const restrict, 
 	gfc_array_i1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_8_i1);
 
 void
 sminloc1_8_i1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_i1 (retarray, array, pdim, back);
+#else
       minloc1_8_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c
index 218b20c..8c7bc19 100644
--- a/libgfortran/generated/minloc1_8_i16.c
+++ b/libgfortran/generated/minloc1_8_i16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_8_i16 (gfc_array_i8 * const restrict, 
-	gfc_array_i16 * const restrict, const index_type * const restrict);
+	gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_8_i16);
 
 void
 minloc1_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_i16 (gfc_array_i8 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_8_i16);
 
 void
 mminloc1_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_i16 (gfc_array_i8 * const restrict, 
 	gfc_array_i16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_8_i16);
 
 void
 sminloc1_8_i16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_i16 (retarray, array, pdim, back);
+#else
       minloc1_8_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c
index 191bcce..e31acb5 100644
--- a/libgfortran/generated/minloc1_8_i2.c
+++ b/libgfortran/generated/minloc1_8_i2.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_8_i2 (gfc_array_i8 * const restrict, 
-	gfc_array_i2 * const restrict, const index_type * const restrict);
+	gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_8_i2);
 
 void
 minloc1_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_i2 (gfc_array_i8 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_8_i2);
 
 void
 mminloc1_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_i2 (gfc_array_i8 * const restrict, 
 	gfc_array_i2 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_8_i2);
 
 void
 sminloc1_8_i2 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i2 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_i2 (retarray, array, pdim, back);
+#else
       minloc1_8_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c
index ff61786..4402bdd 100644
--- a/libgfortran/generated/minloc1_8_i4.c
+++ b/libgfortran/generated/minloc1_8_i4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_8_i4 (gfc_array_i8 * const restrict, 
-	gfc_array_i4 * const restrict, const index_type * const restrict);
+	gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_8_i4);
 
 void
 minloc1_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_i4 (gfc_array_i8 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_8_i4);
 
 void
 mminloc1_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_i4 (gfc_array_i8 * const restrict, 
 	gfc_array_i4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_8_i4);
 
 void
 sminloc1_8_i4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_i4 (retarray, array, pdim, back);
+#else
       minloc1_8_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c
index 42f917c..172cbb5 100644
--- a/libgfortran/generated/minloc1_8_i8.c
+++ b/libgfortran/generated/minloc1_8_i8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_8_i8 (gfc_array_i8 * const restrict, 
-	gfc_array_i8 * const restrict, const index_type * const restrict);
+	gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_8_i8);
 
 void
 minloc1_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_i8 (gfc_array_i8 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_8_i8);
 
 void
 mminloc1_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_i8 (gfc_array_i8 * const restrict, 
 	gfc_array_i8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_8_i8);
 
 void
 sminloc1_8_i8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_i8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_i8 (retarray, array, pdim, back);
+#else
       minloc1_8_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c
index 603f57b..557e876 100644
--- a/libgfortran/generated/minloc1_8_r10.c
+++ b/libgfortran/generated/minloc1_8_r10.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_8_r10 (gfc_array_i8 * const restrict, 
-	gfc_array_r10 * const restrict, const index_type * const restrict);
+	gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_8_r10);
 
 void
 minloc1_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_r10 (gfc_array_i8 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_8_r10);
 
 void
 mminloc1_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_r10 (gfc_array_i8 * const restrict, 
 	gfc_array_r10 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_8_r10);
 
 void
 sminloc1_8_r10 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r10 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_r10 (retarray, array, pdim, back);
+#else
       minloc1_8_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c
index cad0d00..184dd1e 100644
--- a/libgfortran/generated/minloc1_8_r16.c
+++ b/libgfortran/generated/minloc1_8_r16.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_8_r16 (gfc_array_i8 * const restrict, 
-	gfc_array_r16 * const restrict, const index_type * const restrict);
+	gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_8_r16);
 
 void
 minloc1_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_r16 (gfc_array_i8 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_8_r16);
 
 void
 mminloc1_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_r16 (gfc_array_i8 * const restrict, 
 	gfc_array_r16 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_8_r16);
 
 void
 sminloc1_8_r16 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r16 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_r16 (retarray, array, pdim, back);
+#else
       minloc1_8_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c
index 15d7482..fd81020 100644
--- a/libgfortran/generated/minloc1_8_r4.c
+++ b/libgfortran/generated/minloc1_8_r4.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_8_r4 (gfc_array_i8 * const restrict, 
-	gfc_array_r4 * const restrict, const index_type * const restrict);
+	gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_8_r4);
 
 void
 minloc1_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_r4 (gfc_array_i8 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_8_r4);
 
 void
 mminloc1_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_r4 (gfc_array_i8 * const restrict, 
 	gfc_array_r4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_8_r4);
 
 void
 sminloc1_8_r4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_r4 (retarray, array, pdim, back);
+#else
       minloc1_8_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c
index 7cd1c9d..fc0ff7c 100644
--- a/libgfortran/generated/minloc1_8_r8.c
+++ b/libgfortran/generated/minloc1_8_r8.c
@@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include "libgfortran.h"
+#include <assert.h>
 
 
 #if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 
 extern void minloc1_8_r8 (gfc_array_i8 * const restrict, 
-	gfc_array_r8 * const restrict, const index_type * const restrict);
+	gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
 export_proto(minloc1_8_r8);
 
 void
 minloc1_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
-	const index_type * const restrict pdim)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -51,6 +54,10 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -214,14 +221,14 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_r8 (gfc_array_i8 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
 export_proto(mminloc1_8_r8);
 
 void
 mminloc1_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -239,6 +246,9 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -433,14 +443,14 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_r8 (gfc_array_i8 * const restrict, 
 	gfc_array_r8 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
 export_proto(sminloc1_8_r8);
 
 void
 sminloc1_8_r8 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_r8 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -453,7 +463,11 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_r8 (retarray, array, pdim, back);
+#else
       minloc1_8_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_s1.c b/libgfortran/generated/minloc1_8_s1.c
index 8428db2..b5b4fd5 100644
--- a/libgfortran/generated/minloc1_8_s1.c
+++ b/libgfortran/generated/minloc1_8_s1.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
 }
 
 extern void minloc1_8_s1 (gfc_array_i8 * const restrict, 
-	gfc_array_s1 * const restrict, const index_type * const restrict,
+	gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(minloc1_8_s1);
 
 void
 minloc1_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ minloc1_8_s1 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ minloc1_8_s1 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_s1 (gfc_array_i8 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mminloc1_8_s1);
 
 void
 mminloc1_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mminloc1_8_s1 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mminloc1_8_s1 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_s1 (gfc_array_i8 * const restrict, 
 	gfc_array_s1 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc1_8_s1);
 
 void
 sminloc1_8_s1 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s1 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ sminloc1_8_s1 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_s1 (retarray, array, pdim, back, string_len);
+#else
       minloc1_8_s1 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc1_8_s4.c b/libgfortran/generated/minloc1_8_s4.c
index 8042dd2..4181630 100644
--- a/libgfortran/generated/minloc1_8_s4.c
+++ b/libgfortran/generated/minloc1_8_s4.c
@@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
+#define HAVE_BACK_ARG 1
+
 #include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
@@ -40,14 +43,15 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
 }
 
 extern void minloc1_8_s4 (gfc_array_i8 * const restrict, 
-	gfc_array_s4 * const restrict, const index_type * const restrict,
+	gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
 	gfc_charlen_type);
 export_proto(minloc1_8_s4);
 
 void
 minloc1_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+	const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -62,6 +66,10 @@ minloc1_8_s4 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -210,14 +218,15 @@ minloc1_8_s4 (gfc_array_i8 * const restrict retarray,
 
 extern void mminloc1_8_s4 (gfc_array_i8 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
+	gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(mminloc1_8_s4);
 
 void
 mminloc1_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -235,6 +244,9 @@ mminloc1_8_s4 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -411,14 +423,14 @@ mminloc1_8_s4 (gfc_array_i8 * const restrict retarray,
 
 extern void sminloc1_8_s4 (gfc_array_i8 * const restrict, 
 	gfc_array_s4 * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
+	GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc1_8_s4);
 
 void
 sminloc1_8_s4 (gfc_array_i8 * const restrict retarray, 
 	gfc_array_s4 * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -431,7 +443,11 @@ sminloc1_8_s4 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minloc1_8_s4 (retarray, array, pdim, back, string_len);
+#else
       minloc1_8_s4 (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minloc2_16_s1.c b/libgfortran/generated/minloc2_16_s1.c
index 841aeeb..3685603 100644
--- a/libgfortran/generated/minloc2_16_s1.c
+++ b/libgfortran/generated/minloc2_16_s1.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
 
@@ -38,11 +39,13 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_16 minloc2_16_s1 (gfc_array_s1 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_16 minloc2_16_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
+       gfc_charlen_type);
 export_proto(minloc2_16_s1);
 
 GFC_INTEGER_16
-minloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+minloc2_16_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back,
+				gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -51,6 +54,7 @@ minloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_1 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -73,12 +77,14 @@ minloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_16 mminloc2_16_s1 (gfc_array_s1 * const restrict,
-                    gfc_array_l1 *const restrict mask, gfc_charlen_type);
+                    gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+		    gfc_charlen_type);
 export_proto(mminloc2_16_s1);
 
 GFC_INTEGER_16
 mminloc2_16_s1 (gfc_array_s1 * const restrict array,
-				 gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+				 gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -90,6 +96,7 @@ mminloc2_16_s1 (gfc_array_s1 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert (back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -139,15 +146,15 @@ mminloc2_16_s1 (gfc_array_s1 * const restrict array,
 }
 
 extern GFC_INTEGER_16 sminloc2_16_s1 (gfc_array_s1 * const restrict,
-       		    	GFC_LOGICAL_4 *mask, gfc_charlen_type);
+       		    	GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc2_16_s1);
 
 GFC_INTEGER_16
 sminloc2_16_s1 (gfc_array_s1 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return minloc2_16_s1 (array, len);
+    return minloc2_16_s1 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/minloc2_16_s4.c b/libgfortran/generated/minloc2_16_s4.c
index 7b71642..256784f 100644
--- a/libgfortran/generated/minloc2_16_s4.c
+++ b/libgfortran/generated/minloc2_16_s4.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
 
@@ -38,11 +39,13 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_16 minloc2_16_s4 (gfc_array_s4 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_16 minloc2_16_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
+       gfc_charlen_type);
 export_proto(minloc2_16_s4);
 
 GFC_INTEGER_16
-minloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+minloc2_16_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back,
+				gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -51,6 +54,7 @@ minloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_4 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -73,12 +77,14 @@ minloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_16 mminloc2_16_s4 (gfc_array_s4 * const restrict,
-                    gfc_array_l1 *const restrict mask, gfc_charlen_type);
+                    gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+		    gfc_charlen_type);
 export_proto(mminloc2_16_s4);
 
 GFC_INTEGER_16
 mminloc2_16_s4 (gfc_array_s4 * const restrict array,
-				 gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+				 gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -90,6 +96,7 @@ mminloc2_16_s4 (gfc_array_s4 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert (back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -139,15 +146,15 @@ mminloc2_16_s4 (gfc_array_s4 * const restrict array,
 }
 
 extern GFC_INTEGER_16 sminloc2_16_s4 (gfc_array_s4 * const restrict,
-       		    	GFC_LOGICAL_4 *mask, gfc_charlen_type);
+       		    	GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc2_16_s4);
 
 GFC_INTEGER_16
 sminloc2_16_s4 (gfc_array_s4 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return minloc2_16_s4 (array, len);
+    return minloc2_16_s4 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/minloc2_4_s1.c b/libgfortran/generated/minloc2_4_s1.c
index d5b88e1..1ba34d1 100644
--- a/libgfortran/generated/minloc2_4_s1.c
+++ b/libgfortran/generated/minloc2_4_s1.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
 
@@ -38,11 +39,13 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_4 minloc2_4_s1 (gfc_array_s1 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_4 minloc2_4_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
+       gfc_charlen_type);
 export_proto(minloc2_4_s1);
 
 GFC_INTEGER_4
-minloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+minloc2_4_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back,
+				gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -51,6 +54,7 @@ minloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_1 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -73,12 +77,14 @@ minloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_4 mminloc2_4_s1 (gfc_array_s1 * const restrict,
-                    gfc_array_l1 *const restrict mask, gfc_charlen_type);
+                    gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+		    gfc_charlen_type);
 export_proto(mminloc2_4_s1);
 
 GFC_INTEGER_4
 mminloc2_4_s1 (gfc_array_s1 * const restrict array,
-				 gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+				 gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -90,6 +96,7 @@ mminloc2_4_s1 (gfc_array_s1 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert (back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -139,15 +146,15 @@ mminloc2_4_s1 (gfc_array_s1 * const restrict array,
 }
 
 extern GFC_INTEGER_4 sminloc2_4_s1 (gfc_array_s1 * const restrict,
-       		    	GFC_LOGICAL_4 *mask, gfc_charlen_type);
+       		    	GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc2_4_s1);
 
 GFC_INTEGER_4
 sminloc2_4_s1 (gfc_array_s1 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return minloc2_4_s1 (array, len);
+    return minloc2_4_s1 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/minloc2_4_s4.c b/libgfortran/generated/minloc2_4_s4.c
index 6213778..cd5053d 100644
--- a/libgfortran/generated/minloc2_4_s4.c
+++ b/libgfortran/generated/minloc2_4_s4.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
 
@@ -38,11 +39,13 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_4 minloc2_4_s4 (gfc_array_s4 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_4 minloc2_4_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
+       gfc_charlen_type);
 export_proto(minloc2_4_s4);
 
 GFC_INTEGER_4
-minloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+minloc2_4_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back,
+				gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -51,6 +54,7 @@ minloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_4 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -73,12 +77,14 @@ minloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_4 mminloc2_4_s4 (gfc_array_s4 * const restrict,
-                    gfc_array_l1 *const restrict mask, gfc_charlen_type);
+                    gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+		    gfc_charlen_type);
 export_proto(mminloc2_4_s4);
 
 GFC_INTEGER_4
 mminloc2_4_s4 (gfc_array_s4 * const restrict array,
-				 gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+				 gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -90,6 +96,7 @@ mminloc2_4_s4 (gfc_array_s4 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert (back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -139,15 +146,15 @@ mminloc2_4_s4 (gfc_array_s4 * const restrict array,
 }
 
 extern GFC_INTEGER_4 sminloc2_4_s4 (gfc_array_s4 * const restrict,
-       		    	GFC_LOGICAL_4 *mask, gfc_charlen_type);
+       		    	GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc2_4_s4);
 
 GFC_INTEGER_4
 sminloc2_4_s4 (gfc_array_s4 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return minloc2_4_s4 (array, len);
+    return minloc2_4_s4 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/minloc2_8_s1.c b/libgfortran/generated/minloc2_8_s1.c
index 7aacd28..5c73d89 100644
--- a/libgfortran/generated/minloc2_8_s1.c
+++ b/libgfortran/generated/minloc2_8_s1.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
 
@@ -38,11 +39,13 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_8 minloc2_8_s1 (gfc_array_s1 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_8 minloc2_8_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
+       gfc_charlen_type);
 export_proto(minloc2_8_s1);
 
 GFC_INTEGER_8
-minloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+minloc2_8_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back,
+				gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -51,6 +54,7 @@ minloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_1 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -73,12 +77,14 @@ minloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_8 mminloc2_8_s1 (gfc_array_s1 * const restrict,
-                    gfc_array_l1 *const restrict mask, gfc_charlen_type);
+                    gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+		    gfc_charlen_type);
 export_proto(mminloc2_8_s1);
 
 GFC_INTEGER_8
 mminloc2_8_s1 (gfc_array_s1 * const restrict array,
-				 gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+				 gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -90,6 +96,7 @@ mminloc2_8_s1 (gfc_array_s1 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert (back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -139,15 +146,15 @@ mminloc2_8_s1 (gfc_array_s1 * const restrict array,
 }
 
 extern GFC_INTEGER_8 sminloc2_8_s1 (gfc_array_s1 * const restrict,
-       		    	GFC_LOGICAL_4 *mask, gfc_charlen_type);
+       		    	GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc2_8_s1);
 
 GFC_INTEGER_8
 sminloc2_8_s1 (gfc_array_s1 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return minloc2_8_s1 (array, len);
+    return minloc2_8_s1 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/minloc2_8_s4.c b/libgfortran/generated/minloc2_8_s4.c
index c94bc74..9b40c91 100644
--- a/libgfortran/generated/minloc2_8_s4.c
+++ b/libgfortran/generated/minloc2_8_s4.c
@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "libgfortran.h"
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
 
@@ -38,11 +39,13 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern GFC_INTEGER_8 minloc2_8_s4 (gfc_array_s4 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_8 minloc2_8_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
+       gfc_charlen_type);
 export_proto(minloc2_8_s4);
 
 GFC_INTEGER_8
-minloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+minloc2_8_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back,
+				gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -51,6 +54,7 @@ minloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
   const GFC_INTEGER_4 *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -73,12 +77,14 @@ minloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
 }
 
 extern GFC_INTEGER_8 mminloc2_8_s4 (gfc_array_s4 * const restrict,
-                    gfc_array_l1 *const restrict mask, gfc_charlen_type);
+                    gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+		    gfc_charlen_type);
 export_proto(mminloc2_8_s4);
 
 GFC_INTEGER_8
 mminloc2_8_s4 (gfc_array_s4 * const restrict array,
-				 gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+				 gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+				 gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -90,6 +96,7 @@ mminloc2_8_s4 (gfc_array_s4 * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert (back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -139,15 +146,15 @@ mminloc2_8_s4 (gfc_array_s4 * const restrict array,
 }
 
 extern GFC_INTEGER_8 sminloc2_8_s4 (gfc_array_s4 * const restrict,
-       		    	GFC_LOGICAL_4 *mask, gfc_charlen_type);
+       		    	GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
 export_proto(sminloc2_8_s4);
 
 GFC_INTEGER_8
 sminloc2_8_s4 (gfc_array_s4 * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
 {
   if (mask)
-    return minloc2_8_s4 (array, len);
+    return minloc2_8_s4 (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c
index f57c5ab..7bb6f81 100644
--- a/libgfortran/generated/minval_i1.c
+++ b/libgfortran/generated/minval_i1.c
@@ -51,6 +51,10 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minval_i1 (retarray, array, pdim, back);
+#else
       minval_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c
index 11781a6..b2608bc 100644
--- a/libgfortran/generated/minval_i16.c
+++ b/libgfortran/generated/minval_i16.c
@@ -51,6 +51,10 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minval_i16 (retarray, array, pdim, back);
+#else
       minval_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c
index b786985..6539ae1 100644
--- a/libgfortran/generated/minval_i2.c
+++ b/libgfortran/generated/minval_i2.c
@@ -51,6 +51,10 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minval_i2 (retarray, array, pdim, back);
+#else
       minval_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c
index ecd0b4e..e2c16d2 100644
--- a/libgfortran/generated/minval_i4.c
+++ b/libgfortran/generated/minval_i4.c
@@ -51,6 +51,10 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minval_i4 (retarray, array, pdim, back);
+#else
       minval_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c
index a4e8f78..9caafd9 100644
--- a/libgfortran/generated/minval_i8.c
+++ b/libgfortran/generated/minval_i8.c
@@ -51,6 +51,10 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minval_i8 (retarray, array, pdim, back);
+#else
       minval_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c
index 0ac2185..308f64b 100644
--- a/libgfortran/generated/minval_r10.c
+++ b/libgfortran/generated/minval_r10.c
@@ -51,6 +51,10 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ sminval_r10 (gfc_array_r10 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minval_r10 (retarray, array, pdim, back);
+#else
       minval_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c
index bee1289..948aee0 100644
--- a/libgfortran/generated/minval_r16.c
+++ b/libgfortran/generated/minval_r16.c
@@ -51,6 +51,10 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ sminval_r16 (gfc_array_r16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minval_r16 (retarray, array, pdim, back);
+#else
       minval_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c
index d47a9c8..b52a3e8 100644
--- a/libgfortran/generated/minval_r4.c
+++ b/libgfortran/generated/minval_r4.c
@@ -51,6 +51,10 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ sminval_r4 (gfc_array_r4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minval_r4 (retarray, array, pdim, back);
+#else
       minval_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c
index 0552847..34caf05 100644
--- a/libgfortran/generated/minval_r8.c
+++ b/libgfortran/generated/minval_r8.c
@@ -51,6 +51,10 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -232,6 +236,9 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -441,7 +448,11 @@ sminval_r8 (gfc_array_r8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      minval_r8 (retarray, array, pdim, back);
+#else
       minval_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/norm2_r10.c b/libgfortran/generated/norm2_r10.c
index 37b3a87..b6e5a4a 100644
--- a/libgfortran/generated/norm2_r10.c
+++ b/libgfortran/generated/norm2_r10.c
@@ -54,6 +54,10 @@ norm2_r10 (gfc_array_r10 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
diff --git a/libgfortran/generated/norm2_r16.c b/libgfortran/generated/norm2_r16.c
index faa06ba..32237db 100644
--- a/libgfortran/generated/norm2_r16.c
+++ b/libgfortran/generated/norm2_r16.c
@@ -58,6 +58,10 @@ norm2_r16 (gfc_array_r16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
diff --git a/libgfortran/generated/norm2_r4.c b/libgfortran/generated/norm2_r4.c
index 22a006b..504d313 100644
--- a/libgfortran/generated/norm2_r4.c
+++ b/libgfortran/generated/norm2_r4.c
@@ -54,6 +54,10 @@ norm2_r4 (gfc_array_r4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
diff --git a/libgfortran/generated/norm2_r8.c b/libgfortran/generated/norm2_r8.c
index 7b2a5ae..60e707f 100644
--- a/libgfortran/generated/norm2_r8.c
+++ b/libgfortran/generated/norm2_r8.c
@@ -54,6 +54,10 @@ norm2_r8 (gfc_array_r8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
diff --git a/libgfortran/generated/parity_l1.c b/libgfortran/generated/parity_l1.c
index fe4e5c8..2920799 100644
--- a/libgfortran/generated/parity_l1.c
+++ b/libgfortran/generated/parity_l1.c
@@ -51,6 +51,10 @@ parity_l1 (gfc_array_l1 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
diff --git a/libgfortran/generated/parity_l16.c b/libgfortran/generated/parity_l16.c
index b74882c..c1ac0b2 100644
--- a/libgfortran/generated/parity_l16.c
+++ b/libgfortran/generated/parity_l16.c
@@ -51,6 +51,10 @@ parity_l16 (gfc_array_l16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
diff --git a/libgfortran/generated/parity_l2.c b/libgfortran/generated/parity_l2.c
index 9c0b0eb..c588e72 100644
--- a/libgfortran/generated/parity_l2.c
+++ b/libgfortran/generated/parity_l2.c
@@ -51,6 +51,10 @@ parity_l2 (gfc_array_l2 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
diff --git a/libgfortran/generated/parity_l4.c b/libgfortran/generated/parity_l4.c
index 7506605..0acb039 100644
--- a/libgfortran/generated/parity_l4.c
+++ b/libgfortran/generated/parity_l4.c
@@ -51,6 +51,10 @@ parity_l4 (gfc_array_l4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
diff --git a/libgfortran/generated/parity_l8.c b/libgfortran/generated/parity_l8.c
index 273c272..84623df 100644
--- a/libgfortran/generated/parity_l8.c
+++ b/libgfortran/generated/parity_l8.c
@@ -51,6 +51,10 @@ parity_l8 (gfc_array_l8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
diff --git a/libgfortran/generated/product_c10.c b/libgfortran/generated/product_c10.c
index d78bab9..38e8251 100644
--- a/libgfortran/generated/product_c10.c
+++ b/libgfortran/generated/product_c10.c
@@ -51,6 +51,10 @@ product_c10 (gfc_array_c10 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_c10 (retarray, array, pdim, back);
+#else
       product_c10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_c16.c b/libgfortran/generated/product_c16.c
index 7b6b1ee..d1c04ec 100644
--- a/libgfortran/generated/product_c16.c
+++ b/libgfortran/generated/product_c16.c
@@ -51,6 +51,10 @@ product_c16 (gfc_array_c16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_c16 (retarray, array, pdim, back);
+#else
       product_c16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_c4.c b/libgfortran/generated/product_c4.c
index ddb28bc..d19cfaf 100644
--- a/libgfortran/generated/product_c4.c
+++ b/libgfortran/generated/product_c4.c
@@ -51,6 +51,10 @@ product_c4 (gfc_array_c4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_c4 (retarray, array, pdim, back);
+#else
       product_c4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_c8.c b/libgfortran/generated/product_c8.c
index e1705bc..ed1e12a 100644
--- a/libgfortran/generated/product_c8.c
+++ b/libgfortran/generated/product_c8.c
@@ -51,6 +51,10 @@ product_c8 (gfc_array_c8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_c8 (retarray, array, pdim, back);
+#else
       product_c8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_i1.c b/libgfortran/generated/product_i1.c
index 38f6f21..2e86e99 100644
--- a/libgfortran/generated/product_i1.c
+++ b/libgfortran/generated/product_i1.c
@@ -51,6 +51,10 @@ product_i1 (gfc_array_i1 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_i1 (retarray, array, pdim, back);
+#else
       product_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_i16.c b/libgfortran/generated/product_i16.c
index 58c51fb..f23890e 100644
--- a/libgfortran/generated/product_i16.c
+++ b/libgfortran/generated/product_i16.c
@@ -51,6 +51,10 @@ product_i16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_i16 (retarray, array, pdim, back);
+#else
       product_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_i2.c b/libgfortran/generated/product_i2.c
index b91ca75..762e548 100644
--- a/libgfortran/generated/product_i2.c
+++ b/libgfortran/generated/product_i2.c
@@ -51,6 +51,10 @@ product_i2 (gfc_array_i2 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_i2 (retarray, array, pdim, back);
+#else
       product_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_i4.c b/libgfortran/generated/product_i4.c
index 246dc7e..ecf0470 100644
--- a/libgfortran/generated/product_i4.c
+++ b/libgfortran/generated/product_i4.c
@@ -51,6 +51,10 @@ product_i4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_i4 (retarray, array, pdim, back);
+#else
       product_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_i8.c b/libgfortran/generated/product_i8.c
index a0e264f..a9530ec 100644
--- a/libgfortran/generated/product_i8.c
+++ b/libgfortran/generated/product_i8.c
@@ -51,6 +51,10 @@ product_i8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_i8 (retarray, array, pdim, back);
+#else
       product_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_r10.c b/libgfortran/generated/product_r10.c
index decefd7..613ed18 100644
--- a/libgfortran/generated/product_r10.c
+++ b/libgfortran/generated/product_r10.c
@@ -51,6 +51,10 @@ product_r10 (gfc_array_r10 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_r10 (retarray, array, pdim, back);
+#else
       product_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_r16.c b/libgfortran/generated/product_r16.c
index 66f3ef9..9befd51 100644
--- a/libgfortran/generated/product_r16.c
+++ b/libgfortran/generated/product_r16.c
@@ -51,6 +51,10 @@ product_r16 (gfc_array_r16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_r16 (retarray, array, pdim, back);
+#else
       product_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_r4.c b/libgfortran/generated/product_r4.c
index 0f5f1f5..5e356ee 100644
--- a/libgfortran/generated/product_r4.c
+++ b/libgfortran/generated/product_r4.c
@@ -51,6 +51,10 @@ product_r4 (gfc_array_r4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_r4 (retarray, array, pdim, back);
+#else
       product_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/product_r8.c b/libgfortran/generated/product_r8.c
index 75ed99c..4e98cfa 100644
--- a/libgfortran/generated/product_r8.c
+++ b/libgfortran/generated/product_r8.c
@@ -51,6 +51,10 @@ product_r8 (gfc_array_r8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      product_r8 (retarray, array, pdim, back);
+#else
       product_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c
index 9083745..6923594 100644
--- a/libgfortran/generated/sum_c10.c
+++ b/libgfortran/generated/sum_c10.c
@@ -51,6 +51,10 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_c10 (gfc_array_c10 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_c10 (retarray, array, pdim, back);
+#else
       sum_c10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_c16.c b/libgfortran/generated/sum_c16.c
index 15c2d6b..4ed50d0 100644
--- a/libgfortran/generated/sum_c16.c
+++ b/libgfortran/generated/sum_c16.c
@@ -51,6 +51,10 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_c16 (gfc_array_c16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_c16 (retarray, array, pdim, back);
+#else
       sum_c16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_c4.c b/libgfortran/generated/sum_c4.c
index 654ed60..9d5516a 100644
--- a/libgfortran/generated/sum_c4.c
+++ b/libgfortran/generated/sum_c4.c
@@ -51,6 +51,10 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_c4 (gfc_array_c4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_c4 (retarray, array, pdim, back);
+#else
       sum_c4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_c8.c b/libgfortran/generated/sum_c8.c
index 1313c5d..84684cb 100644
--- a/libgfortran/generated/sum_c8.c
+++ b/libgfortran/generated/sum_c8.c
@@ -51,6 +51,10 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_c8 (gfc_array_c8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_c8 (retarray, array, pdim, back);
+#else
       sum_c8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_i1.c b/libgfortran/generated/sum_i1.c
index a6d3043..f440702 100644
--- a/libgfortran/generated/sum_i1.c
+++ b/libgfortran/generated/sum_i1.c
@@ -51,6 +51,10 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_i1 (retarray, array, pdim, back);
+#else
       sum_i1 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_i16.c b/libgfortran/generated/sum_i16.c
index d8f80b0..570f8f2 100644
--- a/libgfortran/generated/sum_i16.c
+++ b/libgfortran/generated/sum_i16.c
@@ -51,6 +51,10 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_i16 (retarray, array, pdim, back);
+#else
       sum_i16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_i2.c b/libgfortran/generated/sum_i2.c
index 49209c4..ea70d50 100644
--- a/libgfortran/generated/sum_i2.c
+++ b/libgfortran/generated/sum_i2.c
@@ -51,6 +51,10 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_i2 (retarray, array, pdim, back);
+#else
       sum_i2 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_i4.c b/libgfortran/generated/sum_i4.c
index 39954d1..4915ec9 100644
--- a/libgfortran/generated/sum_i4.c
+++ b/libgfortran/generated/sum_i4.c
@@ -51,6 +51,10 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_i4 (retarray, array, pdim, back);
+#else
       sum_i4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_i8.c b/libgfortran/generated/sum_i8.c
index 6fb7d9b..53f6ec2 100644
--- a/libgfortran/generated/sum_i8.c
+++ b/libgfortran/generated/sum_i8.c
@@ -51,6 +51,10 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_i8 (retarray, array, pdim, back);
+#else
       sum_i8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_r10.c b/libgfortran/generated/sum_r10.c
index dcafdec8..9552ed8 100644
--- a/libgfortran/generated/sum_r10.c
+++ b/libgfortran/generated/sum_r10.c
@@ -51,6 +51,10 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_r10 (gfc_array_r10 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_r10 (retarray, array, pdim, back);
+#else
       sum_r10 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_r16.c b/libgfortran/generated/sum_r16.c
index e230e61..6c83206 100644
--- a/libgfortran/generated/sum_r16.c
+++ b/libgfortran/generated/sum_r16.c
@@ -51,6 +51,10 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_r16 (gfc_array_r16 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_r16 (retarray, array, pdim, back);
+#else
       sum_r16 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_r4.c b/libgfortran/generated/sum_r4.c
index a2bca49..1595336 100644
--- a/libgfortran/generated/sum_r4.c
+++ b/libgfortran/generated/sum_r4.c
@@ -51,6 +51,10 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_r4 (gfc_array_r4 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_r4 (retarray, array, pdim, back);
+#else
       sum_r4 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/generated/sum_r8.c b/libgfortran/generated/sum_r8.c
index 7c2836e..7c8a186 100644
--- a/libgfortran/generated/sum_r8.c
+++ b/libgfortran/generated/sum_r8.c
@@ -51,6 +51,10 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -218,6 +222,9 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -399,7 +406,11 @@ ssum_r8 (gfc_array_r8 * const restrict retarray,
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      sum_r8 (retarray, array, pdim, back);
+#else
       sum_r8 (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/m4/iforeach-s.m4 b/libgfortran/m4/iforeach-s.m4
index c62a1f7..9711925 100644
--- a/libgfortran/m4/iforeach-s.m4
+++ b/libgfortran/m4/iforeach-s.m4
@@ -13,23 +13,27 @@ compare_fcn (const atype_name *a, const atype_name *b, gfc_charlen_type n)
 
 }
 
-extern void name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array, gfc_charlen_type len);
-export_proto(name`'rtype_qual`_'atype_code);
+extern void name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array'back_arg`, gfc_charlen_type len);
+export_proto('name`'rtype_qual`_'atype_code);
 
 void
-name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array, gfc_charlen_type len)
+name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array'back_arg`, gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
   index_type sstride[GFC_MAX_DIMENSIONS];
   index_type dstride;
-  const atype_name *base;
+  const 'atype_name *base;
   rtype_name * restrict dest;
   index_type rank;
   index_type n;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
+
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -112,27 +116,32 @@ define(FINISH_FOREACH_FUNCTION,
 }')dnl
 define(START_MASKED_FOREACH_FUNCTION,
 `
-extern void `m'name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
-export_proto(`m'name`'rtype_qual`_'atype_code);
+extern void `m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict, 
+	'atype` * const restrict, gfc_array_l1 * const restrict 'back_arg`,
+	gfc_charlen_type len);
+export_proto(m'name`'rtype_qual`_'atype_code`);
 
 void
-`m'name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array,
-	gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array,
+	gfc_array_l1 * const restrict mask'back_arg`,
+	gfc_charlen_type len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
   index_type sstride[GFC_MAX_DIMENSIONS];
   index_type mstride[GFC_MAX_DIMENSIONS];
   index_type dstride;
-  rtype_name *dest;
+  'rtype_name *dest;
   const atype_name *base;
   GFC_LOGICAL_1 *mbase;
   int rank;
   index_type n;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -243,23 +252,29 @@ $2
 FINISH_MASKED_FOREACH_FUNCTION')dnl
 define(SCALAR_FOREACH_FUNCTION,
 `
-extern void `s'name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
-export_proto(`s'name`'rtype_qual`_'atype_code);
+extern void `s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict, 
+	'atype` * const restrict, GFC_LOGICAL_4 *'back_arg`,
+	gfc_charlen_type len);
+export_proto(s'name`'rtype_qual`_'atype_code);
 
 void
-`s'name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array,
-	GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+`s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array,
+	GFC_LOGICAL_4 * mask'back_arg`,
+	gfc_charlen_type len)
 {
   index_type rank;
   index_type dstride;
   index_type n;
-  rtype_name *dest;
+  'rtype_name *dest;
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG    
+      name`'rtype_qual`_'atype_code (retarray, array, back, len);
+#else
       name`'rtype_qual`_'atype_code (retarray, array, len);
+#endif
       return;
     }
 
diff --git a/libgfortran/m4/iforeach.m4 b/libgfortran/m4/iforeach.m4
index 2b9e7dd..e6365cc 100644
--- a/libgfortran/m4/iforeach.m4
+++ b/libgfortran/m4/iforeach.m4
@@ -5,12 +5,12 @@ dnl Distributed under the GNU GPL with exception.  See COPYING for details.
 define(START_FOREACH_FUNCTION,
 `
 extern void name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array);
+	atype * const restrict array, GFC_LOGICAL_4);
 export_proto(name`'rtype_qual`_'atype_code);
 
 void
 name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array)
+	atype * const restrict array, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -21,6 +21,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
   index_type rank;
   index_type n;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -104,13 +105,14 @@ define(FINISH_FOREACH_FUNCTION,
 define(START_MASKED_FOREACH_FUNCTION,
 `
 extern void `m'name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, gfc_array_l1 * const restrict);
+	atype * const restrict, gfc_array_l1 * const restrict,
+	GFC_LOGICAL_4);
 export_proto(`m'name`'rtype_qual`_'atype_code);
 
 void
 `m'name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
 	atype * const restrict array,
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
@@ -124,6 +126,7 @@ void
   index_type n;
   int mask_kind;
 
+  assert(back == 0);
   rank = GFC_DESCRIPTOR_RANK (array);
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
@@ -235,13 +238,13 @@ FINISH_MASKED_FOREACH_FUNCTION')dnl
 define(SCALAR_FOREACH_FUNCTION,
 `
 extern void `s'name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, GFC_LOGICAL_4 *);
+	atype * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
 export_proto(`s'name`'rtype_qual`_'atype_code);
 
 void
 `s'name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
 	atype * const restrict array,
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
 {
   index_type rank;
   index_type dstride;
@@ -250,7 +253,7 @@ void
 
   if (*mask)
     {
-      name`'rtype_qual`_'atype_code (retarray, array);
+      name`'rtype_qual`_'atype_code (retarray, array, back);
       return;
     }
 
diff --git a/libgfortran/m4/ifunction-s.m4 b/libgfortran/m4/ifunction-s.m4
index 0f0c28f..9b4d96a 100644
--- a/libgfortran/m4/ifunction-s.m4
+++ b/libgfortran/m4/ifunction-s.m4
@@ -19,6 +19,7 @@ dnl You should not return or break from the inner loop of the implementation.
 dnl Care should also be taken to avoid using the names defined in iparm.m4
 define(START_ARRAY_FUNCTION,
 `#include <string.h>
+#include <assert.h>
 
 static inline int
 compare_fcn (const atype_name *a, const atype_name *b, gfc_charlen_type n)
@@ -29,21 +30,22 @@ compare_fcn (const atype_name *a, const atype_name *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern void name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, const index_type * const restrict,
+extern void name`'rtype_qual`_'atype_code (rtype` * const restrict, 
+	'atype` * const restrict, const index_type * const restrict 'back_arg`,
 	gfc_charlen_type);
-export_proto(name`'rtype_qual`_'atype_code);
+export_proto('name`'rtype_qual`_'atype_code`);
 
 void
-name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array, 
-	const index_type * const restrict pdim, gfc_charlen_type string_len)
+'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array, 
+	const index_type * const restrict pdim'back_arg`,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
   index_type sstride[GFC_MAX_DIMENSIONS];
   index_type dstride[GFC_MAX_DIMENSIONS];
-  const atype_name * restrict base;
+  const 'atype_name * restrict base;
   rtype_name * restrict dest;
   index_type rank;
   index_type n;
@@ -52,6 +54,10 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -192,23 +198,24 @@ define(FINISH_ARRAY_FUNCTION,
 }')dnl
 define(START_MASKED_ARRAY_FUNCTION,
 `
-extern void `m'name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict, gfc_charlen_type);
-export_proto(`m'name`'rtype_qual`_'atype_code);
+extern void `m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict, 
+	'atype` * const restrict, const index_type * const restrict,
+	gfc_array_l1 * const restrict'back_arg`, gfc_charlen_type);
+export_proto(m'name`'rtype_qual`_'atype_code`);
 
 void
-`m'name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array, 
+m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+	gfc_array_l1 * const restrict mask'back_arg`,
+	gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
   index_type sstride[GFC_MAX_DIMENSIONS];
   index_type dstride[GFC_MAX_DIMENSIONS];
   index_type mstride[GFC_MAX_DIMENSIONS];
-  rtype_name * restrict dest;
+  'rtype_name * restrict dest;
   const atype_name * restrict base;
   const GFC_LOGICAL_1 * restrict mbase;
   index_type rank;
@@ -219,6 +226,9 @@ void
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -377,21 +387,21 @@ define(FINISH_MASKED_ARRAY_FUNCTION,
 }')dnl
 define(SCALAR_ARRAY_FUNCTION,
 `
-extern void `s'name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *, gfc_charlen_type);
-export_proto(`s'name`'rtype_qual`_'atype_code);
+extern void `s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict, 
+	'atype` * const restrict, const index_type * const restrict,
+	GFC_LOGICAL_4 *'back_arg`, gfc_charlen_type);
+export_proto(s'name`'rtype_qual`_'atype_code`);
 
 void
-`s'name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array, 
+s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+	GFC_LOGICAL_4 * mask 'back_arg`, gfc_charlen_type string_len)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
   index_type dstride[GFC_MAX_DIMENSIONS];
-  rtype_name * restrict dest;
+  'rtype_name * restrict dest;
   index_type rank;
   index_type n;
   index_type dim;
@@ -399,7 +409,11 @@ void
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      name`'rtype_qual`_'atype_code (retarray, array, pdim, back, string_len);
+#else
       name`'rtype_qual`_'atype_code (retarray, array, pdim, string_len);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/m4/ifunction.m4 b/libgfortran/m4/ifunction.m4
index fa10a8b..8df072d 100644
--- a/libgfortran/m4/ifunction.m4
+++ b/libgfortran/m4/ifunction.m4
@@ -20,19 +20,19 @@ dnl Care should also be taken to avoid using the names defined in iparm.m4
 define(START_ARRAY_FUNCTION,
 `
 extern void name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, const index_type * const restrict);
-export_proto(name`'rtype_qual`_'atype_code);
+	atype` * const restrict, const 'index_type` * const restrict'back_arg`);
+export_proto('name`'rtype_qual`_'atype_code);
 
 void
-name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array, 
-	const index_type * const restrict pdim)
+name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array, 
+	const index_type * const restrict pdim'back_arg`)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
   index_type sstride[GFC_MAX_DIMENSIONS];
   index_type dstride[GFC_MAX_DIMENSIONS];
-  const atype_name * restrict base;
+  const 'atype_name * restrict base;
   rtype_name * restrict dest;
   index_type rank;
   index_type n;
@@ -41,6 +41,10 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
   index_type dim;
   int continue_loop;
 
+#ifdef HAVE_BACK_ARG
+  assert(back == 0);
+#endif
+
   /* Make dim zero based to avoid confusion.  */
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
   dim = (*pdim) - 1;
@@ -181,23 +185,23 @@ define(FINISH_ARRAY_FUNCTION,
 }')dnl
 define(START_MASKED_ARRAY_FUNCTION,
 `
-extern void `m'name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, const index_type * const restrict,
-	gfc_array_l1 * const restrict);
-export_proto(`m'name`'rtype_qual`_'atype_code);
+extern void `m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict, 
+	'atype` * const restrict, const 'index_type` * const restrict,
+	gfc_array_l1 * const restrict'back_arg`);
+export_proto(m'name`'rtype_qual`_'atype_code`);
 
 void
-`m'name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array, 
+m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array, 
 	const index_type * const restrict pdim, 
-	gfc_array_l1 * const restrict mask)
+	gfc_array_l1 * const restrict mask'back_arg`)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
   index_type sstride[GFC_MAX_DIMENSIONS];
   index_type dstride[GFC_MAX_DIMENSIONS];
   index_type mstride[GFC_MAX_DIMENSIONS];
-  rtype_name * restrict dest;
+  'rtype_name * restrict dest;
   const atype_name * restrict base;
   const GFC_LOGICAL_1 * restrict mbase;
   index_type rank;
@@ -208,6 +212,9 @@ void
   index_type mdelta;
   int mask_kind;
 
+#ifdef HAVE_BACK_ARG
+  assert (back == 0);
+#endif
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
@@ -366,21 +373,21 @@ define(FINISH_MASKED_ARRAY_FUNCTION,
 }')dnl
 define(SCALAR_ARRAY_FUNCTION,
 `
-extern void `s'name`'rtype_qual`_'atype_code (rtype * const restrict, 
-	atype * const restrict, const index_type * const restrict,
-	GFC_LOGICAL_4 *);
-export_proto(`s'name`'rtype_qual`_'atype_code);
+extern void `s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict, 
+	'atype` * const restrict, const index_type * const restrict,
+	GFC_LOGICAL_4 *'back_arg`);
+export_proto(s'name`'rtype_qual`_'atype_code);
 
 void
-`s'name`'rtype_qual`_'atype_code (rtype * const restrict retarray, 
-	atype * const restrict array, 
+`s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray, 
+	'atype` * const restrict array, 
 	const index_type * const restrict pdim, 
-	GFC_LOGICAL_4 * mask)
+	GFC_LOGICAL_4 * mask'back_arg`)
 {
   index_type count[GFC_MAX_DIMENSIONS];
   index_type extent[GFC_MAX_DIMENSIONS];
   index_type dstride[GFC_MAX_DIMENSIONS];
-  rtype_name * restrict dest;
+  'rtype_name * restrict dest;
   index_type rank;
   index_type n;
   index_type dim;
@@ -388,7 +395,11 @@ void
 
   if (*mask)
     {
+#ifdef HAVE_BACK_ARG
+      name`'rtype_qual`_'atype_code (retarray, array, pdim, back);
+#else
       name`'rtype_qual`_'atype_code (retarray, array, pdim);
+#endif
       return;
     }
   /* Make dim zero based to avoid confusion.  */
diff --git a/libgfortran/m4/iparm.m4 b/libgfortran/m4/iparm.m4
index a5596c9..23f05ce 100644
--- a/libgfortran/m4/iparm.m4
+++ b/libgfortran/m4/iparm.m4
@@ -36,3 +36,5 @@ define(`upcase', `translit(`$*', `a-z', `A-Z')')dnl
 define(`u_name',`regexp(upcase(name),`\([A-Z]*\)',`\1')')dnl
 define(rtype_ccode,ifelse(rtype_letter,`i',rtype_kind,rtype_code))dnl
 define(initval,ifelse(index(name,`maxval'),0,0,index(name,`minval'),0,255))dnl
+define(back_arg,ifelse(index(name,`maxloc'),0,``, GFC_LOGICAL_4 back'',dnl
+index(name,`minloc'),0,``, GFC_LOGICAL_4 back''))dnl
diff --git a/libgfortran/m4/maxloc0.m4 b/libgfortran/m4/maxloc0.m4
index 05e50e9..98d898f 100644
--- a/libgfortran/m4/maxloc0.m4
+++ b/libgfortran/m4/maxloc0.m4
@@ -23,7 +23,8 @@ a copy of the GCC Runtime Library Exception along with this program;
 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
-#include "libgfortran.h"'
+#include "libgfortran.h"
+#include <assert.h>'
 
 include(iparm.m4)dnl
 include(iforeach.m4)dnl
diff --git a/libgfortran/m4/maxloc0s.m4 b/libgfortran/m4/maxloc0s.m4
index 95bba3c..3c30a66 100644
--- a/libgfortran/m4/maxloc0s.m4
+++ b/libgfortran/m4/maxloc0s.m4
@@ -34,6 +34,8 @@ include(iforeach-s.m4)dnl
 
 `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
 
+#define HAVE_BACK_ARG 1
+
 FOREACH_FUNCTION(
 `  const atype_name *maxval;
    maxval = base;'
diff --git a/libgfortran/m4/maxloc1.m4 b/libgfortran/m4/maxloc1.m4
index 37e0772..324a699 100644
--- a/libgfortran/m4/maxloc1.m4
+++ b/libgfortran/m4/maxloc1.m4
@@ -23,13 +23,16 @@ a copy of the GCC Runtime Library Exception along with this program;
 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
-#include "libgfortran.h"'
+#include "libgfortran.h"
+#include <assert.h>'
 
 include(iparm.m4)dnl
 include(ifunction.m4)dnl
 
 `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
 
+#define HAVE_BACK_ARG 1
+
 ARRAY_FUNCTION(0,
 `	atype_name maxval;
 #if defined ('atype_inf`)
diff --git a/libgfortran/m4/maxloc1s.m4 b/libgfortran/m4/maxloc1s.m4
index 31b5444..23da4ab 100644
--- a/libgfortran/m4/maxloc1s.m4
+++ b/libgfortran/m4/maxloc1s.m4
@@ -30,6 +30,8 @@ include(ifunction-s.m4)dnl
 
 `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
 
+#define HAVE_BACK_ARG 1
+
 ARRAY_FUNCTION(0,
 `	const atype_name *maxval;
 	maxval = base;
diff --git a/libgfortran/m4/maxloc2s.m4 b/libgfortran/m4/maxloc2s.m4
index 4af5eeb..5138f69 100644
--- a/libgfortran/m4/maxloc2s.m4
+++ b/libgfortran/m4/maxloc2s.m4
@@ -25,7 +25,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #include "libgfortran.h"
 #include <stdlib.h>
-#include <string.h>'
+#include <string.h>
+#include <assert.h>'
 include(iparm.m4)dnl
 
 `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)
@@ -39,12 +40,12 @@ compare_fcn (const 'atype_name` *a, const 'atype_name` *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern 'rtype_name` 'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
+extern 'rtype_name` 'name`'rtype_qual`_'atype_code` ('atype` * const restrict'back_arg`,
        gfc_charlen_type);
 export_proto('name`'rtype_qual`_'atype_code`);
 
 'rtype_name`
-'name`'rtype_qual`_'atype_code` ('atype` * const restrict array, gfc_charlen_type len)
+'name`'rtype_qual`_'atype_code` ('atype` * const restrict array'back_arg`, gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -53,6 +54,7 @@ export_proto('name`'rtype_qual`_'atype_code`);
   const 'atype_name` *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -75,12 +77,13 @@ export_proto('name`'rtype_qual`_'atype_code`);
 }
 
 extern 'rtype_name` m'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
-       		    	gfc_array_l1 *const restrict mask, gfc_charlen_type);
+       		    	gfc_array_l1 *const restrict mask'back_arg`,
+			gfc_charlen_type);
 export_proto(m'name`'rtype_qual`_'atype_code`);
 
 'rtype_name`
 m'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
-				 gfc_array_l1 * const restrict mask,
+				 gfc_array_l1 * const restrict mask'back_arg`,
 				 gfc_charlen_type len)
 {
   index_type ret;
@@ -93,6 +96,7 @@ m'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -142,15 +146,15 @@ m'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
 }
 
 extern 'rtype_name` s'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
-                               GFC_LOGICAL_4 *mask, gfc_charlen_type);
+                               GFC_LOGICAL_4 *mask'back_arg`, gfc_charlen_type);
 export_proto(s'name`'rtype_qual`_'atype_code`);
 
 'rtype_name`
 s'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask'back_arg`, gfc_charlen_type len)
 {
   if (mask)
-    return 'name`'rtype_qual`_'atype_code` (array, len);
+    return 'name`'rtype_qual`_'atype_code` (array, len, back);
   else
     return 0;
 }
diff --git a/libgfortran/m4/minloc0.m4 b/libgfortran/m4/minloc0.m4
index e40821e..78c60d9 100644
--- a/libgfortran/m4/minloc0.m4
+++ b/libgfortran/m4/minloc0.m4
@@ -23,7 +23,8 @@ a copy of the GCC Runtime Library Exception along with this program;
 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
-#include "libgfortran.h"'
+#include "libgfortran.h"
+#include <assert.h>'
 
 include(iparm.m4)dnl
 include(iforeach.m4)dnl
diff --git a/libgfortran/m4/minloc0s.m4 b/libgfortran/m4/minloc0s.m4
index 3b3fcf5..c4b9f46 100644
--- a/libgfortran/m4/minloc0s.m4
+++ b/libgfortran/m4/minloc0s.m4
@@ -34,6 +34,8 @@ include(iforeach-s.m4)dnl
 
 `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
 
+#define HAVE_BACK_ARG 1
+
 FOREACH_FUNCTION(
 `  const atype_name *minval;
    minval = base;'
diff --git a/libgfortran/m4/minloc1.m4 b/libgfortran/m4/minloc1.m4
index fafa1a9..ebf52f0 100644
--- a/libgfortran/m4/minloc1.m4
+++ b/libgfortran/m4/minloc1.m4
@@ -23,13 +23,16 @@ a copy of the GCC Runtime Library Exception along with this program;
 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
-#include "libgfortran.h"'
+#include "libgfortran.h"
+#include <assert.h>'
 
 include(iparm.m4)dnl
 include(ifunction.m4)dnl
 
 `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
 
+#define HAVE_BACK_ARG 1
+
 ARRAY_FUNCTION(0,
 `	atype_name minval;
 #if defined ('atype_inf`)
diff --git a/libgfortran/m4/minloc1s.m4 b/libgfortran/m4/minloc1s.m4
index f2dc8c3..6e46631 100644
--- a/libgfortran/m4/minloc1s.m4
+++ b/libgfortran/m4/minloc1s.m4
@@ -30,6 +30,8 @@ include(ifunction-s.m4)dnl
 
 `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
 
+#define HAVE_BACK_ARG 1
+
 ARRAY_FUNCTION(0,
 `	const atype_name *minval;
 	minval = base;
diff --git a/libgfortran/m4/minloc2s.m4 b/libgfortran/m4/minloc2s.m4
index c485567..2df71bb 100644
--- a/libgfortran/m4/minloc2s.m4
+++ b/libgfortran/m4/minloc2s.m4
@@ -25,7 +25,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 #include "libgfortran.h"
 #include <stdlib.h>
-#include <string.h>'
+#include <string.h>
+#include <assert.h>'
 include(iparm.m4)dnl
 
 `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)
@@ -39,11 +40,13 @@ compare_fcn (const 'atype_name` *a, const 'atype_name` *b, gfc_charlen_type n)
     return memcmp_char4 (a, b, n);
 }
 
-extern 'rtype_name` 'name`'rtype_qual`_'atype_code` ('atype` * const restrict, gfc_charlen_type);
+extern 'rtype_name` 'name`'rtype_qual`_'atype_code` ('atype` * const restrict'back_arg`,
+       gfc_charlen_type);
 export_proto('name`'rtype_qual`_'atype_code`);
 
 'rtype_name`
-'name`'rtype_qual`_'atype_code` ('atype` * const restrict array, gfc_charlen_type len)
+'name`'rtype_qual`_'atype_code` ('atype` * const restrict array'back_arg`,
+				gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -52,6 +55,7 @@ export_proto('name`'rtype_qual`_'atype_code`);
   const 'atype_name` *maxval;
   index_type i;
 
+  assert(back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -74,12 +78,14 @@ export_proto('name`'rtype_qual`_'atype_code`);
 }
 
 extern 'rtype_name` m'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
-                    gfc_array_l1 *const restrict mask, gfc_charlen_type);
+                    gfc_array_l1 *const restrict mask'back_arg`,
+		    gfc_charlen_type);
 export_proto(m'name`'rtype_qual`_'atype_code`);
 
 'rtype_name`
 m'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
-				 gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+				 gfc_array_l1 * const restrict mask'back_arg`,
+				 gfc_charlen_type len)
 {
   index_type ret;
   index_type sstride;
@@ -91,6 +97,7 @@ m'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
   int mask_kind;
   index_type mstride;
 
+  assert (back == 0);
   extent = GFC_DESCRIPTOR_EXTENT(array,0);
   if (extent <= 0)
     return 0;
@@ -140,15 +147,15 @@ m'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
 }
 
 extern 'rtype_name` s'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
-       		    	GFC_LOGICAL_4 *mask, gfc_charlen_type);
+       		    	GFC_LOGICAL_4 *mask'back_arg`, gfc_charlen_type);
 export_proto(s'name`'rtype_qual`_'atype_code`);
 
 'rtype_name`
 s'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
-				 GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+				 GFC_LOGICAL_4 *mask'back_arg`, gfc_charlen_type len)
 {
   if (mask)
-    return 'name`'rtype_qual`_'atype_code` (array, len);
+    return 'name`'rtype_qual`_'atype_code` (array, len, back);
   else
     return 0;
 }