diff --git a/src/Infrastructure/Array/interface/ESMF_ArrayCreate.cppF90 b/src/Infrastructure/Array/interface/ESMF_ArrayCreate.cppF90
index 1c3589169e..e3babaf003 100644
--- a/src/Infrastructure/Array/interface/ESMF_ArrayCreate.cppF90
+++ b/src/Infrastructure/Array/interface/ESMF_ArrayCreate.cppF90
@@ -295,7 +295,7 @@ contains
 ! !IROUTINE:  ESMF_ArrayEQ - Compare two Calendars for equality
 !
 ! !INTERFACE:
-  function ESMF_ArrayEQ(array1, array2)
+  impure elemental function ESMF_ArrayEQ(array1, array2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_ArrayEQ
@@ -346,7 +346,7 @@ contains
 ! !IROUTINE:  ESMF_ArrayNE - Compare two Calendars for non-equality
 !
 ! !INTERFACE:
-  function ESMF_ArrayNE(array1, array2)
+  impure elemental function ESMF_ArrayNE(array1, array2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_ArrayNE
diff --git a/src/Infrastructure/ArrayBundle/interface/ESMF_ArrayBundle.F90 b/src/Infrastructure/ArrayBundle/interface/ESMF_ArrayBundle.F90
index 0f32edc9b4..3d6f65f323 100644
--- a/src/Infrastructure/ArrayBundle/interface/ESMF_ArrayBundle.F90
+++ b/src/Infrastructure/ArrayBundle/interface/ESMF_ArrayBundle.F90
@@ -369,7 +369,7 @@ subroutine c_ESMC_ArrayBundleSMMStore(srcArrayBundle, dstArrayBundle, &
 ! !IROUTINE:  ESMF_ArrayBundleEQ - Compare two ArrayBundles for equality
 !
 ! !INTERFACE:
-  function ESMF_ArrayBundleEQ(arraybundle1, arraybundle2)
+  impure elemental function ESMF_ArrayBundleEQ(arraybundle1, arraybundle2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_ArrayBundleEQ
@@ -420,7 +420,7 @@ end function ESMF_ArrayBundleEQ
 ! !IROUTINE:  ESMF_ArrayBundleNE - Compare two ArrayBundles for non-equality
 !
 ! !INTERFACE:
-  function ESMF_ArrayBundleNE(arraybundle1, arraybundle2)
+    impure elemental function ESMF_ArrayBundleNE(arraybundle1, arraybundle2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_ArrayBundleNE
diff --git a/src/Infrastructure/ArraySpec/src/ESMF_ArraySpec.F90 b/src/Infrastructure/ArraySpec/src/ESMF_ArraySpec.F90
index abff8d984d..2cd35a86e4 100644
--- a/src/Infrastructure/ArraySpec/src/ESMF_ArraySpec.F90
+++ b/src/Infrastructure/ArraySpec/src/ESMF_ArraySpec.F90
@@ -242,7 +242,7 @@ module ESMF_ArraySpecMod
 ! !IROUTINE: ESMF_ArraySpecEQ - Test if ArraySpec 1 is equal to ArraySpec 2
 !
 ! !INTERFACE:
-  function ESMF_ArraySpecEQ(arrayspec1, arrayspec2)
+  impure elemental function ESMF_ArraySpecEQ(arrayspec1, arrayspec2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_ArraySpecEQ
@@ -281,7 +281,7 @@ end function ESMF_ArraySpecEQ
 ! !IROUTINE: ESMF_ArraySpecNE - Test if ArraySpec 1 is not equal to ArraySpec 2
 !
 ! !INTERFACE:
-  function ESMF_ArraySpecNE(arrayspec1, arrayspec2)
+  impure elemental function ESMF_ArraySpecNE(arrayspec1, arrayspec2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_ArraySpecNE
diff --git a/src/Infrastructure/Base/interface/ESMF_Info.F90 b/src/Infrastructure/Base/interface/ESMF_Info.F90
index b3cb358fb1..2bd747f103 100644
--- a/src/Infrastructure/Base/interface/ESMF_Info.F90
+++ b/src/Infrastructure/Base/interface/ESMF_Info.F90
@@ -253,7 +253,7 @@ module ESMF_InfoMod
 
 #undef  ESMF_METHOD
 #define ESMF_METHOD "ESMF_InfoEqual()"
-function ESMF_InfoEqual(lhs, rhs) result(is_equal)
+impure elemental function ESMF_InfoEqual(lhs, rhs) result(is_equal)
   type(ESMF_Info), intent(in) :: lhs
   type(ESMF_Info), intent(in) :: rhs
   logical :: is_equal
@@ -271,7 +271,7 @@ end function ESMF_InfoEqual
 
 #undef  ESMF_METHOD
 #define ESMF_METHOD "ESMF_InfoNotEqual()"
-function ESMF_InfoNotEqual(lhs, rhs) result(is_equal)
+impure elemental function ESMF_InfoNotEqual(lhs, rhs) result(is_equal)
   type(ESMF_Info), intent(in) :: lhs
   type(ESMF_Info), intent(in) :: rhs
   logical :: is_equal
diff --git a/src/Infrastructure/Config/src/ESMF_Config.F90 b/src/Infrastructure/Config/src/ESMF_Config.F90
index 6815f70514..280e5fe480 100644
--- a/src/Infrastructure/Config/src/ESMF_Config.F90
+++ b/src/Infrastructure/Config/src/ESMF_Config.F90
@@ -3923,7 +3923,7 @@ end subroutine ESMF_ConfigValidate
 ! !IROUTINE:  ESMF_ConfigEQ - Compare two Config objects for equality
 !
 ! !INTERFACE:
-  function ESMF_ConfigEQ(Config1, Config2)
+  impure elemental function ESMF_ConfigEQ(Config1, Config2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_ConfigEQ
@@ -3949,7 +3949,7 @@ end function ESMF_ConfigEQ
 ! !IROUTINE:  ESMF_ConfigEQ - Compare two Config objects for inequality
 !
 ! !INTERFACE:
-  function ESMF_ConfigNE(Config1, Config2)
+  impure elemental function ESMF_ConfigNE(Config1, Config2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_ConfigNE
diff --git a/src/Infrastructure/DELayout/interface/ESMF_DELayout.F90 b/src/Infrastructure/DELayout/interface/ESMF_DELayout.F90
index 8ebbeb50ea..249740d1f8 100644
--- a/src/Infrastructure/DELayout/interface/ESMF_DELayout.F90
+++ b/src/Infrastructure/DELayout/interface/ESMF_DELayout.F90
@@ -322,7 +322,7 @@ module ESMF_DELayoutMod
 ! !IROUTINE:  ESMF_DELayoutEQ - Compare two DELayouts for equality
 !
 ! !INTERFACE:
-  function ESMF_DELayoutEQ(delayout1, delayout2)
+  impure elemental function ESMF_DELayoutEQ(delayout1, delayout2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_DELayoutEQ
@@ -373,7 +373,7 @@ end function ESMF_DELayoutEQ
 ! !IROUTINE:  ESMF_DELayoutNE - Compare two DELayouts for non-equality
 !
 ! !INTERFACE:
-  function ESMF_DELayoutNE(delayout1, delayout2)
+  impure elemental function ESMF_DELayoutNE(delayout1, delayout2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_DELayoutNE
diff --git a/src/Infrastructure/DistGrid/interface/ESMF_DistGrid.F90 b/src/Infrastructure/DistGrid/interface/ESMF_DistGrid.F90
index 4b0145650b..7ae21c614e 100644
--- a/src/Infrastructure/DistGrid/interface/ESMF_DistGrid.F90
+++ b/src/Infrastructure/DistGrid/interface/ESMF_DistGrid.F90
@@ -440,7 +440,7 @@ module ESMF_DistGridMod
 ! !IROUTINE:  ESMF_DistGridEQ - Compare two DistGrids for equality
 !
 ! !INTERFACE:
-  function ESMF_DistGridEQ(distgrid1, distgrid2)
+  impure elemental function ESMF_DistGridEQ(distgrid1, distgrid2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_DistGridEQ
@@ -491,7 +491,7 @@ end function ESMF_DistGridEQ
 ! !IROUTINE:  ESMF_DistGridNE - Compare two DistGrids for non-equality
 !
 ! !INTERFACE:
-  function ESMF_DistGridNE(distgrid1, distgrid2)
+  impure elemental function ESMF_DistGridNE(distgrid1, distgrid2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_DistGridNE
diff --git a/src/Infrastructure/Field/src/ESMF_Field.F90 b/src/Infrastructure/Field/src/ESMF_Field.F90
index be261a194c..b3bd886a61 100644
--- a/src/Infrastructure/Field/src/ESMF_Field.F90
+++ b/src/Infrastructure/Field/src/ESMF_Field.F90
@@ -789,14 +789,14 @@ end subroutine ESMF_FieldInitialize
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_Status flags to see if they're the same or not
 
-function ESMF_sfeq(sf1, sf2)
+impure elemental function ESMF_sfeq(sf1, sf2)
  logical ESMF_sfeq
  type(ESMF_FieldStatus_Flag), intent(in) :: sf1, sf2
 
  ESMF_sfeq = (sf1%status == sf2%status)
 end function
 
-function ESMF_sfne(sf1, sf2)
+impure elemental function ESMF_sfne(sf1, sf2)
  logical ESMF_sfne
  type(ESMF_FieldStatus_Flag), intent(in) :: sf1, sf2
 
diff --git a/src/Infrastructure/Field/src/ESMF_FieldCreate.cppF90 b/src/Infrastructure/Field/src/ESMF_FieldCreate.cppF90
index b11e182de6..5a3bef786c 100644
--- a/src/Infrastructure/Field/src/ESMF_FieldCreate.cppF90
+++ b/src/Infrastructure/Field/src/ESMF_FieldCreate.cppF90
@@ -279,7 +279,7 @@ contains
 ! !IROUTINE:  ESMF_FieldEQ - Compare two Fields for equality
 !
 ! !INTERFACE:
-  function ESMF_FieldEQ(field1, field2)
+  impure elemental function ESMF_FieldEQ(field1, field2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_FieldEQ
@@ -330,7 +330,7 @@ contains
 ! !IROUTINE:  ESMF_FieldNE - Compare two Fields for non-equality
 !
 ! !INTERFACE:
-  function ESMF_FieldNE(field1, field2)
+  impure elemental function ESMF_FieldNE(field1, field2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_FieldNE
diff --git a/src/Infrastructure/FieldBundle/src/ESMF_FieldBundle.cppF90 b/src/Infrastructure/FieldBundle/src/ESMF_FieldBundle.cppF90
index 40187dd094..57616e585d 100644
--- a/src/Infrastructure/FieldBundle/src/ESMF_FieldBundle.cppF90
+++ b/src/Infrastructure/FieldBundle/src/ESMF_FieldBundle.cppF90
@@ -490,7 +490,7 @@ contains
 ! !IROUTINE:  ESMF_FieldBundleEQ - Compare two FieldBundles for equality
 !
 ! !INTERFACE:
-  function ESMF_FieldBundleEQ(fieldbundle1, fieldbundle2)
+  impure elemental function ESMF_FieldBundleEQ(fieldbundle1, fieldbundle2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_FieldBundleEQ
@@ -541,7 +541,7 @@ contains
 ! !IROUTINE:  ESMF_FieldBundleNE - Compare two FieldBundles for non-equality
 !
 ! !INTERFACE:
-  function ESMF_FieldBundleNE(fieldbundle1, fieldbundle2)
+  impure elemental function ESMF_FieldBundleNE(fieldbundle1, fieldbundle2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_FieldBundleNE
diff --git a/src/Infrastructure/Geom/src/ESMF_Geom.F90 b/src/Infrastructure/Geom/src/ESMF_Geom.F90
index 47ab2f4e6e..b14a0f68ab 100644
--- a/src/Infrastructure/Geom/src/ESMF_Geom.F90
+++ b/src/Infrastructure/Geom/src/ESMF_Geom.F90
@@ -1753,7 +1753,7 @@ end function ESMF_GeomGetInit
 ! !IROUTINE: ESMF_GeomTypeEqual - Equality of GeomTypes
 !
 ! !INTERFACE:
-      function ESMF_GeomTypeEqual(GeomType1, GeomType2)
+      impure elemental function ESMF_GeomTypeEqual(GeomType1, GeomType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GeomTypeEqual
@@ -1787,7 +1787,7 @@ end function ESMF_GeomTypeEqual
 ! !IROUTINE: ESMF_GeomTypeNotEqual - Non-equality of GeomTypes
 !
 ! !INTERFACE:
-      function ESMF_GeomTypeNotEqual(GeomType1, GeomType2)
+      impure elemental function ESMF_GeomTypeNotEqual(GeomType1, GeomType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GeomTypeNotEqual
diff --git a/src/Infrastructure/Grid/interface/ESMF_Grid.F90 b/src/Infrastructure/Grid/interface/ESMF_Grid.F90
index 7f777260f9..4d2b77c94b 100644
--- a/src/Infrastructure/Grid/interface/ESMF_Grid.F90
+++ b/src/Infrastructure/Grid/interface/ESMF_Grid.F90
@@ -1193,7 +1193,7 @@ module ESMF_GridMod
 ! !IROUTINE:  ESMF_GridEQ - Compare two Grids for equality
 !
 ! !INTERFACE:
-  function ESMF_GridEQ(grid1, grid2)
+  impure elemental function ESMF_GridEQ(grid1, grid2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_GridEQ
@@ -1244,7 +1244,7 @@ end function ESMF_GridEQ
 ! !IROUTINE:  ESMF_GridNE - Compare two Grids for non-equality
 !
 ! !INTERFACE:
-  function ESMF_GridNE(grid1, grid2)
+  impure elemental function ESMF_GridNE(grid1, grid2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_GridNE
@@ -28021,7 +28021,7 @@ end function ESMF_GridGetInit
 ! !IROUTINE: ESMF_GridConnEqual - Equality of GridConns
 !
 ! !INTERFACE:
-      function ESMF_GridConnEqual(GridConn1, GridConn2)
+      impure elemental function ESMF_GridConnEqual(GridConn1, GridConn2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GridConnEqual
@@ -28055,7 +28055,7 @@ end function ESMF_GridConnEqual
 ! !IROUTINE: ESMF_GridConnNotEqual - Non-equality of GridConns
 !
 ! !INTERFACE:
-      function ESMF_GridConnNotEqual(GridConn1, GridConn2)
+      impure elemental function ESMF_GridConnNotEqual(GridConn1, GridConn2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GridConnNotEqual
@@ -28091,7 +28091,7 @@ end function ESMF_GridConnNotEqual
 ! !IROUTINE: ESMF_GridDecompEqual - Equality of GridDecomps
 !
 ! !INTERFACE:
-      function ESMF_GridDecompEqual(GridDecomp1, GridDecomp2)
+      impure elemental function ESMF_GridDecompEqual(GridDecomp1, GridDecomp2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GridDecompEqual
@@ -28125,7 +28125,7 @@ end function ESMF_GridDecompEqual
 ! !IROUTINE: ESMF_GridDecompNotEqual - Non-equality of GridDecomps
 !
 ! !INTERFACE:
-      function ESMF_GridDecompNotEqual(GridDecomp1, GridDecomp2)
+      impure elemental function ESMF_GridDecompNotEqual(GridDecomp1, GridDecomp2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GridDecompNotEqual
@@ -28644,7 +28644,7 @@ end subroutine ESMF_GridStatusAssignment
 ! !IROUTINE: ESMF_GridStatusEqual - Equality of GridStatus statuses
 !
 ! !INTERFACE:
-      function ESMF_GridStatusEqual(GridStatus1, GridStatus2)
+      impure elemental function ESMF_GridStatusEqual(GridStatus1, GridStatus2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GridStatusEqual
@@ -28678,7 +28678,7 @@ end function ESMF_GridStatusEqual
 ! !IROUTINE: ESMF_GridStatusNotEqual - Non-equality of GridStatus statuses
 !
 ! !INTERFACE:
-      function ESMF_GridStatusNotEqual(GridStatus1, GridStatus2)
+      impure elemental function ESMF_GridStatusNotEqual(GridStatus1, GridStatus2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GridStatusNotEqual
@@ -28855,7 +28855,7 @@ end function ESMF_GridStatusLessEqual
 ! !IROUTINE: ESMF_GridMatchEqual - Equality of GridMatch statuses
 !
 ! !INTERFACE:
-      function ESMF_GridMatchEqual(GridMatch1, GridMatch2)
+      impure elemental function ESMF_GridMatchEqual(GridMatch1, GridMatch2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GridMatchEqual
@@ -28889,7 +28889,7 @@ end function ESMF_GridMatchEqual
 ! !IROUTINE: ESMF_GridMatchNotEqual - Non-equality of GridMatch statuses
 !
 ! !INTERFACE:
-      function ESMF_GridMatchNotEqual(GridMatch1, GridMatch2)
+      impure elemental function ESMF_GridMatchNotEqual(GridMatch1, GridMatch2)
 
 ! !RETURN VALUE:
       logical :: ESMF_GridMatchNotEqual
@@ -31220,7 +31220,7 @@ end subroutine SetupTileConn
 ! !IROUTINE: ESMF_PoleTypeEqual - Equality of PoleType statuses
 !
 ! !INTERFACE:
-      function ESMF_PoleTypeEqual(PoleType1, PoleType2)
+      impure elemental function ESMF_PoleTypeEqual(PoleType1, PoleType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_PoleTypeEqual
@@ -31254,7 +31254,7 @@ end function ESMF_PoleTypeEqual
 ! !IROUTINE: ESMF_PoleTypeNotEqual - Non-equality of PoleType statuses
 !
 ! !INTERFACE:
-      function ESMF_PoleTypeNotEqual(PoleType1, PoleType2)
+      impure elemental function ESMF_PoleTypeNotEqual(PoleType1, PoleType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_PoleTypeNotEqual
diff --git a/src/Infrastructure/LocStream/src/ESMF_LocStream.F90 b/src/Infrastructure/LocStream/src/ESMF_LocStream.F90
index b07fd14310..93edce7860 100644
--- a/src/Infrastructure/LocStream/src/ESMF_LocStream.F90
+++ b/src/Infrastructure/LocStream/src/ESMF_LocStream.F90
@@ -367,7 +367,7 @@ module ESMF_LocStreamMod
 ! !IROUTINE:  ESMF_LocStreamEQ - Compare two LocStreams for equality
 !
 ! !INTERFACE:
-  function ESMF_LocStreamEQ(locstream1, locstream2)
+  impure elemental function ESMF_LocStreamEQ(locstream1, locstream2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_LocStreamEQ
@@ -418,7 +418,7 @@ end function ESMF_LocStreamEQ
 ! !IROUTINE:  ESMF_LocStreamNE - Compare two LocStreams for non-equality
 !
 ! !INTERFACE:
-  function ESMF_LocStreamNE(locstream1, locstream2)
+  impure elemental function ESMF_LocStreamNE(locstream1, locstream2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_LocStreamNE
diff --git a/src/Infrastructure/LocalArray/interface/ESMF_LocalArrayCreate.cppF90 b/src/Infrastructure/LocalArray/interface/ESMF_LocalArrayCreate.cppF90
index 2041ce3125..5005ddac18 100644
--- a/src/Infrastructure/LocalArray/interface/ESMF_LocalArrayCreate.cppF90
+++ b/src/Infrastructure/LocalArray/interface/ESMF_LocalArrayCreate.cppF90
@@ -420,7 +420,7 @@ contains
 ! !IROUTINE:  ESMF_LocalArrayEQ - Compare two LocalArrays for equality
 !
 ! !INTERFACE:
-  function ESMF_LocalArrayEQ(localarray1, localarray2)
+  impure elemental function ESMF_LocalArrayEQ(localarray1, localarray2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_LocalArrayEQ
@@ -470,7 +470,7 @@ contains
 ! !IROUTINE:  ESMF_LocalArrayNE - Compare two LocalArrays for non-equality
 !
 ! !INTERFACE:
-  function ESMF_LocalArrayNE(localarray1, localarray2)
+  impure elemental function ESMF_LocalArrayNE(localarray1, localarray2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_LocalArrayNE
@@ -502,14 +502,14 @@ contains
 
 ! functions to compare two ESMF_DataCopy_Flags to see if they are the same or not
 
-function ESMF_cfeq(cf1, cf2)
+impure elemental function ESMF_cfeq(cf1, cf2)
  logical ESMF_cfeq
  type(ESMF_DataCopy_Flag), intent(in) :: cf1, cf2
 
  ESMF_cfeq = (cf1%datacopyflag .eq. cf2%datacopyflag)
 end function
 
-function ESMF_cfne(cf1, cf2)
+impure elemental function ESMF_cfne(cf1, cf2)
  logical ESMF_cfne
  type(ESMF_DataCopy_Flag), intent(in) :: cf1, cf2
 
diff --git a/src/Infrastructure/Mesh/interface/ESMF_Mesh.F90 b/src/Infrastructure/Mesh/interface/ESMF_Mesh.F90
index 426a4c5d86..2c6633aaeb 100644
--- a/src/Infrastructure/Mesh/interface/ESMF_Mesh.F90
+++ b/src/Infrastructure/Mesh/interface/ESMF_Mesh.F90
@@ -383,6 +383,7 @@ module ESMF_MeshMod
 !------------------------------------------------------------------------------
 
 
+
 ! -------------------------- ESMF-public method -------------------------------
 !BOP
 ! !IROUTINE: ESMF_MeshOperator(/=) - Mesh not equal operator
@@ -477,7 +478,7 @@ subroutine ESMF_IntToMeshLoc(lhsMeshLoc, rhsInt)
  ! !IROUTINE:  ESMF_MeshEQ - Compare two Meshes for equality
 !
 ! !INTERFACE:
-  function ESMF_MeshEQ(mesh1, mesh2)
+  impure elemental function ESMF_MeshEQ(mesh1, mesh2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_MeshEQ
@@ -528,7 +529,7 @@ end function ESMF_MeshEQ
 ! !IROUTINE:  ESMF_MeshNE - Compare two Meshes for non-equality
 !
 ! !INTERFACE:
-  function ESMF_MeshNE(mesh1, mesh2)
+  impure elemental function ESMF_MeshNE(mesh1, mesh2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_MeshNE
@@ -6923,7 +6924,7 @@ end function ESMF_MeshStatusNotEqual
 ! !IROUTINE: ESMF_MeshLocEqual - Equality of MeshLocs
 !
 ! !INTERFACE:
-      function ESMF_MeshLocEqual(MeshLoc1, MeshLoc2)
+      impure elemental function ESMF_MeshLocEqual(MeshLoc1, MeshLoc2)
 
 ! !RETURN VALUE:
       logical :: ESMF_MeshLocEqual
diff --git a/src/Infrastructure/TimeMgr/interface/ESMF_Alarm.F90 b/src/Infrastructure/TimeMgr/interface/ESMF_Alarm.F90
index 5896df012d..0f93560799 100644
--- a/src/Infrastructure/TimeMgr/interface/ESMF_Alarm.F90
+++ b/src/Infrastructure/TimeMgr/interface/ESMF_Alarm.F90
@@ -1765,7 +1765,7 @@ end subroutine ESMF_AlarmWriteRestart
 ! !IROUTINE:  ESMF_AlarmEQ - Compare two Alarms for equality
 !
 ! !INTERFACE:
-      function ESMF_AlarmEQ(alarm1, alarm2)
+      impure elemental function ESMF_AlarmEQ(alarm1, alarm2)
 !
 ! !RETURN VALUE:
       logical :: ESMF_AlarmEQ
@@ -1815,7 +1815,7 @@ end function ESMF_AlarmEQ
 ! !IROUTINE:  ESMF_AlarmNE - Compare two Alarms for inequality
 !
 ! !INTERFACE:
-      function ESMF_AlarmNE(alarm1, alarm2)
+      impure elemental function ESMF_AlarmNE(alarm1, alarm2)
 !
 ! !RETURN VALUE:
       logical :: ESMF_AlarmNE
diff --git a/src/Infrastructure/TimeMgr/interface/ESMF_Calendar.F90 b/src/Infrastructure/TimeMgr/interface/ESMF_Calendar.F90
index 0d51cd0877..11fdc3cced 100644
--- a/src/Infrastructure/TimeMgr/interface/ESMF_Calendar.F90
+++ b/src/Infrastructure/TimeMgr/interface/ESMF_Calendar.F90
@@ -1800,7 +1800,7 @@ end subroutine ESMF_CalendarWriteRestart
 ! !IROUTINE:  ESMF_CalendarEQ - Compare two Calendars for equality
 !
 ! !INTERFACE:
-      function ESMF_CalendarEQ(calendar1, calendar2)
+      impure elemental function ESMF_CalendarEQ(calendar1, calendar2)
 ! 
 ! !RETURN VALUE:
       logical :: ESMF_CalendarEQ
@@ -1852,7 +1852,7 @@ end function ESMF_CalendarEQ
 ! !IROUTINE:  ESMF_CalendarKindEQ - Compare two Calendar kinds for equality
 !
 ! !INTERFACE:
-      function ESMF_CalendarKindEQ(calkindflag1, calkindflag2)
+      impure elemental function ESMF_CalendarKindEQ(calkindflag1, calkindflag2)
 ! 
 ! !RETURN VALUE:
       logical :: ESMF_CalendarKindEQ
@@ -1879,7 +1879,7 @@ end function ESMF_CalendarKindEQ
 ! !IROUTINE:  ESMF_CalendarCalAndKindEQ - Compare a Calendar and Calendar kind for equality
 !
 ! !INTERFACE:
-      function ESMF_CalendarCalAndKindEQ(calendar, calkindflag)
+      impure elemental function ESMF_CalendarCalAndKindEQ(calendar, calkindflag)
 ! 
 ! !RETURN VALUE:
       logical :: ESMF_CalendarCalAndKindEQ
@@ -1915,7 +1915,7 @@ end function ESMF_CalendarCalAndKindEQ
 ! !IROUTINE:  ESMF_CalendarKindAndCalEQ - Compare a Calendar kind and Calendar for equality
 !
 ! !INTERFACE:
-      function ESMF_CalendarKindAndCalEQ(calkindflag, calendar)
+      impure elemental function ESMF_CalendarKindAndCalEQ(calkindflag, calendar)
 ! 
 ! !RETURN VALUE:
       logical :: ESMF_CalendarKindAndCalEQ
@@ -1951,7 +1951,7 @@ end function ESMF_CalendarKindAndCalEQ
 ! !IROUTINE:  ESMF_CalendarNE - Compare two Calendars for inequality
 !
 ! !INTERFACE:
-      function ESMF_CalendarNE(calendar1, calendar2)
+      impure elemental function ESMF_CalendarNE(calendar1, calendar2)
 ! 
 ! !RETURN VALUE:
       logical :: ESMF_CalendarNE
@@ -2003,7 +2003,7 @@ end function ESMF_CalendarNE
 ! !IROUTINE:  ESMF_CalendarKindNE - Compare two Calendar kinds for inequality
 !
 ! !INTERFACE:
-      function ESMF_CalendarKindNE(calkindflag1, calkindflag2)
+      impure elemental function ESMF_CalendarKindNE(calkindflag1, calkindflag2)
 ! 
 ! !RETURN VALUE:
       logical :: ESMF_CalendarKindNE
@@ -2030,7 +2030,7 @@ end function ESMF_CalendarKindNE
 ! !IROUTINE:  ESMF_CalendarCalAndKindNE - Compare a Calendar and Calendar kind for inequality
 !
 ! !INTERFACE:
-      function ESMF_CalendarCalAndKindNE(calendar, calkindflag)
+      impure elemental function ESMF_CalendarCalAndKindNE(calendar, calkindflag)
 ! 
 ! !RETURN VALUE:
       logical :: ESMF_CalendarCalAndKindNE
@@ -2066,7 +2066,7 @@ end function ESMF_CalendarCalAndKindNE
 ! !IROUTINE:  ESMF_CalendarKindAndCalNE - Compare a Calendar kind and Calendar for inequality
 !
 ! !INTERFACE:
-      function ESMF_CalendarKindAndCalNE(calkindflag, calendar)
+      impure elemental function ESMF_CalendarKindAndCalNE(calkindflag, calendar)
 ! 
 ! !RETURN VALUE:
       logical :: ESMF_CalendarKindAndCalNE
diff --git a/src/Infrastructure/TimeMgr/interface/ESMF_Clock.F90 b/src/Infrastructure/TimeMgr/interface/ESMF_Clock.F90
index d3e348708d..eb1ef8e9bf 100644
--- a/src/Infrastructure/TimeMgr/interface/ESMF_Clock.F90
+++ b/src/Infrastructure/TimeMgr/interface/ESMF_Clock.F90
@@ -1968,7 +1968,7 @@ end subroutine ESMF_ClockWriteRestart
 ! !IROUTINE:  ESMF_ClockEQ - Compare two Clocks for equality
 !
 ! !INTERFACE:
-      function ESMF_ClockEQ(clock1, clock2)
+      impure elemental function ESMF_ClockEQ(clock1, clock2)
 !
 ! !RETURN VALUE:
       logical :: ESMF_ClockEQ
@@ -2018,7 +2018,7 @@ end function ESMF_ClockEQ
 ! !IROUTINE:  ESMF_ClockNE - Compare two Clocks for inequality
 !
 ! !INTERFACE:
-      function ESMF_ClockNE(clock1, clock2)
+      impure elemental function ESMF_ClockNE(clock1, clock2)
 !
 ! !RETURN VALUE:
       logical :: ESMF_ClockNE
diff --git a/src/Infrastructure/TimeMgr/interface/ESMF_Time.F90 b/src/Infrastructure/TimeMgr/interface/ESMF_Time.F90
index 5ea67d8a24..1f819b50ab 100644
--- a/src/Infrastructure/TimeMgr/interface/ESMF_Time.F90
+++ b/src/Infrastructure/TimeMgr/interface/ESMF_Time.F90
@@ -1707,7 +1707,7 @@ end function ESMF_TimeDiff
 ! !IROUTINE: ESMF_TimeEQ - Test if Time 1 is equal to Time 2
 !
 ! !INTERFACE:
-      function ESMF_TimeEQ(time1, time2)
+      impure elemental function ESMF_TimeEQ(time1, time2)
 !
 ! !RETURN VALUE:
       logical :: ESMF_TimeEQ
@@ -1742,7 +1742,7 @@ end function ESMF_TimeEQ
 ! !IROUTINE: ESMF_TimeNE - Test if Time 1 is not equal to Time 2
 !
 ! !INTERFACE:
-      function ESMF_TimeNE(time1, time2)
+      impure elemental function ESMF_TimeNE(time1, time2)
 !
 ! !RETURN VALUE:
       logical :: ESMF_TimeNE
diff --git a/src/Infrastructure/TimeMgr/interface/ESMF_TimeInterval.F90 b/src/Infrastructure/TimeMgr/interface/ESMF_TimeInterval.F90
index 428c576c46..1db5625ac9 100644
--- a/src/Infrastructure/TimeMgr/interface/ESMF_TimeInterval.F90
+++ b/src/Infrastructure/TimeMgr/interface/ESMF_TimeInterval.F90
@@ -3381,7 +3381,7 @@ end function ESMF_TimeIntervalNegate
 ! !IROUTINE: ESMF_TimeIntervalEQ - Test if TimeInterval 1 is equal to TimeInterval 2
 
 ! !INTERFACE:
-      function ESMF_TimeIntervalEQ(timeinterval1, timeinterval2)
+      impure elemental function ESMF_TimeIntervalEQ(timeinterval1, timeinterval2)
 !
 ! !RETURN VALUE:
       logical :: ESMF_TimeIntervalEQ
@@ -3417,7 +3417,7 @@ end function ESMF_TimeIntervalEQ
 ! !IROUTINE:  ESMF_TimeIntervalNE - Test if TimeInterval 1 is not equal to TimeInterval 2
 
 ! !INTERFACE:
-      function ESMF_TimeIntervalNE(timeinterval1, timeinterval2)
+      impure elemental function ESMF_TimeIntervalNE(timeinterval1, timeinterval2)
 !
 ! !RETURN VALUE:
       logical :: ESMF_TimeIntervalNE
diff --git a/src/Infrastructure/Util/src/ESMF_LogErr.F90 b/src/Infrastructure/Util/src/ESMF_LogErr.F90
index 7cb2684429..2990268678 100644
--- a/src/Infrastructure/Util/src/ESMF_LogErr.F90
+++ b/src/Infrastructure/Util/src/ESMF_LogErr.F90
@@ -717,21 +717,21 @@ end subroutine ESMF_LogEntryValidate
 !------------------------------------------------------------------------------
 ! functions to compare two types to see if they're the same or not
 
-function ESMF_lmteq(mt1, mt2)
+impure elemental function ESMF_lmteq(mt1, mt2)
   logical ESMF_lmteq
   type(ESMF_LogMsg_Flag), intent(in) :: mt1,mt2
 
     ESMF_lmteq = (mt1%mtype == mt2%mtype)
 end function
 
-function ESMF_llteq(lt1, lt2)
+impure elemental function ESMF_llteq(lt1, lt2)
   logical ESMF_llteq
   type(ESMF_LogKind_Flag), intent(in) :: lt1,lt2
 
     ESMF_llteq = (lt1%ftype == lt2%ftype)
 end function
 
-function ESMF_lltne(lt1, lt2)
+impure elemental function ESMF_lltne(lt1, lt2)
   logical ESMF_lltne
   type(ESMF_LogKind_Flag), intent(in) :: lt1,lt2
 
@@ -2825,7 +2825,7 @@ end subroutine ESMF_LogEntryCopy
 ! !IROUTINE:  ESMF_LogEQ - Compare two Logs for equality
 !
 ! !INTERFACE:
-  function ESMF_LogEQ(log1, log2)
+  impure elemental function ESMF_LogEQ(log1, log2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_LogEQ
@@ -2851,7 +2851,7 @@ end function ESMF_LogEQ
 ! !IROUTINE:  ESMF_LogEQ - Compare two Logs for inequality
 !
 ! !INTERFACE:
-  function ESMF_LogNE(log1, log2)
+  impure elemental function ESMF_LogNE(log1, log2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_LogNE
diff --git a/src/Infrastructure/Util/src/ESMF_StaggerLocType.F90 b/src/Infrastructure/Util/src/ESMF_StaggerLocType.F90
index 7ce3c4bc15..e0b44b4855 100644
--- a/src/Infrastructure/Util/src/ESMF_StaggerLocType.F90
+++ b/src/Infrastructure/Util/src/ESMF_StaggerLocType.F90
@@ -286,7 +286,7 @@ subroutine ESMF_IntToStaggerLoc(lhsStaggerLoc, rhsInt)
 ! !IROUTINE: ESMF_StaggerLocEqual - Equality of StaggerLoc statuses
 !
 ! !INTERFACE:
-      function ESMF_StaggerLocEqual(StaggerLoc1, StaggerLoc2)
+      impure elemental function ESMF_StaggerLocEqual(StaggerLoc1, StaggerLoc2)
 
 ! !RETURN VALUE:
       logical :: ESMF_StaggerLocEqual
@@ -320,7 +320,7 @@ end function ESMF_StaggerLocEqual
 ! !IROUTINE: ESMF_StaggerLocNotEqual - Non-equality of StaggerLoc statuses
 !
 ! !INTERFACE:
-      function ESMF_StaggerLocNotEqual(StaggerLoc1, StaggerLoc2)
+      impure elemental function ESMF_StaggerLocNotEqual(StaggerLoc1, StaggerLoc2)
 
 ! !RETURN VALUE:
       logical :: ESMF_StaggerLocNotEqual
diff --git a/src/Infrastructure/Util/src/ESMF_UtilTypes.F90 b/src/Infrastructure/Util/src/ESMF_UtilTypes.F90
index 0373f45ff8..62b3c7379f 100644
--- a/src/Infrastructure/Util/src/ESMF_UtilTypes.F90
+++ b/src/Infrastructure/Util/src/ESMF_UtilTypes.F90
@@ -1507,7 +1507,7 @@ end subroutine ESMF_ObjectIDValidate
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_AttReconcileFlag types
 
-function ESMF_atreceq(atrec1, atrec2)
+impure elemental function ESMF_atreceq(atrec1, atrec2)
   logical ESMF_atreceq
   type(ESMF_AttReconcileFlag), intent(in) :: atrec1, atrec2
 
@@ -1525,7 +1525,7 @@ recursive function ESMF_sfeq(sf1, sf2) result (sfeq)
 end function
 
 recursive function ESMF_sfne(sf1, sf2) result (sfne)
- logical sfne
+ logical :: sfne
  type(ESMF_Status), intent(in) :: sf1, sf2
 
  sfne = (sf1%status /= sf2%status)
@@ -1534,14 +1534,14 @@ recursive function ESMF_sfne(sf1, sf2) result (sfne)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_TypeKinds to see if they're the same or not
 
-function ESMF_dkeq(dk1, dk2)
+impure elemental function ESMF_dkeq(dk1, dk2)
  logical ESMF_dkeq
  type(ESMF_TypeKind_Flag), intent(in) :: dk1, dk2
 
  ESMF_dkeq = (dk1%dkind == dk2%dkind)
 end function
 
-function ESMF_dkne(dk1, dk2)
+impure elemental function ESMF_dkne(dk1, dk2)
  logical ESMF_dkne
  type(ESMF_TypeKind_Flag), intent(in) :: dk1, dk2
 
@@ -1619,14 +1619,14 @@ subroutine ESMF_bfas(bf1, bf2)
  bf1%value = bf2%value
 end subroutine
 
-function ESMF_bfeq(bf1, bf2)
+impure elemental function ESMF_bfeq(bf1, bf2)
  logical ESMF_bfeq
  type(ESMF_Sync_Flag), intent(in) :: bf1, bf2
 
  ESMF_bfeq = (bf1%value == bf2%value)
 end function
 
-function ESMF_bfne(bf1, bf2)
+impure elemental function ESMF_bfne(bf1, bf2)
  logical ESMF_bfne
  type(ESMF_Sync_Flag), intent(in) :: bf1, bf2
 
@@ -1636,14 +1636,14 @@ function ESMF_bfne(bf1, bf2)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_Context_Flags
 
-function ESMF_ctfeq(ctf1, ctf2)
+impure elemental function ESMF_ctfeq(ctf1, ctf2)
  logical ESMF_ctfeq
  type(ESMF_Context_Flag), intent(in) :: ctf1, ctf2
 
  ESMF_ctfeq = (ctf1%value == ctf2%value)
 end function
 
-function ESMF_ctfne(ctf1, ctf2)
+impure elemental function ESMF_ctfne(ctf1, ctf2)
  logical ESMF_ctfne
  type(ESMF_Context_Flag), intent(in) :: ctf1, ctf2
 
@@ -1653,14 +1653,14 @@ function ESMF_ctfne(ctf1, ctf2)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_End_Flags
 
-function ESMF_tnfeq(tnf1, tnf2)
+impure elemental function ESMF_tnfeq(tnf1, tnf2)
  logical ESMF_tnfeq
  type(ESMF_End_Flag), intent(in) :: tnf1, tnf2
 
  ESMF_tnfeq = (tnf1%value == tnf2%value)
 end function
 
-function ESMF_tnfne(tnf1, tnf2)
+impure elemental function ESMF_tnfne(tnf1, tnf2)
  logical ESMF_tnfne
  type(ESMF_End_Flag), intent(in) :: tnf1, tnf2
 
@@ -1670,14 +1670,14 @@ function ESMF_tnfne(tnf1, tnf2)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_Pointers to see if they're the same or not
 
-function ESMF_pteq(pt1, pt2)
+impure elemental function ESMF_pteq(pt1, pt2)
  logical ESMF_pteq
  type(ESMF_Pointer), intent(in) :: pt1, pt2
 
  ESMF_pteq = (pt1%ptr == pt2%ptr)
 end function
 
-function ESMF_ptne(pt1, pt2)
+impure elemental function ESMF_ptne(pt1, pt2)
  logical ESMF_ptne
  type(ESMF_Pointer), intent(in) :: pt1, pt2
 
@@ -1702,14 +1702,14 @@ recursive subroutine ESMF_ptas2(ptval2, ptval)
 ! function to compare two ESMF_Logicals to see if they're the same or not
 ! also assignment to real f90 logical 
 
-function ESMF_tfeq(tf1, tf2)
+impure elemental function ESMF_tfeq(tf1, tf2)
  logical ESMF_tfeq
  type(ESMF_Logical), intent(in) :: tf1, tf2
 
  ESMF_tfeq = (tf1%value == tf2%value)
 end function
 
-function ESMF_tfne(tf1, tf2)
+impure elemental function ESMF_tfne(tf1, tf2)
  logical ESMF_tfne
  type(ESMF_Logical), intent(in) :: tf1, tf2
 
@@ -1747,14 +1747,14 @@ subroutine ESMF_tfas2_v (tfval, lval)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_Pin_Flag types
 
-function ESMF_pineq(pin1, pin2)
+impure elemental function ESMF_pineq(pin1, pin2)
  logical ESMF_pineq
  type(ESMF_Pin_Flag), intent(in) :: pin1, pin2
 
  ESMF_pineq = (pin1%value == pin2%value)
 end function
 
-function ESMF_pinne(pin1, pin2)
+impure elemental function ESMF_pinne(pin1, pin2)
  logical ESMF_pinne
  type(ESMF_Pin_Flag), intent(in) :: pin1, pin2
 
@@ -1764,14 +1764,14 @@ function ESMF_pinne(pin1, pin2)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_Direction_Flag types
 
-function ESMF_freq(fr1, fr2)
+impure elemental function ESMF_freq(fr1, fr2)
  logical ESMF_freq
  type(ESMF_Direction_Flag), intent(in) :: fr1, fr2
 
  ESMF_freq = (fr1%value == fr2%value)
 end function
 
-function ESMF_frne(fr1, fr2)
+impure elemental function ESMF_frne(fr1, fr2)
  logical ESMF_frne
  type(ESMF_Direction_Flag), intent(in) :: fr1, fr2
 
@@ -1788,7 +1788,7 @@ subroutine ESMF_ioas(io1, io2)
  io1%io_type = io2%io_type
 end subroutine
 
-function ESMF_ioeq(io1, io2)
+impure elemental function ESMF_ioeq(io1, io2)
   logical ESMF_ioeq
   type(ESMF_IOFmt_Flag), intent(in) :: io1, io2
 
@@ -1798,14 +1798,14 @@ function ESMF_ioeq(io1, io2)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_Index_Flag types
 
-function ESMF_ifeq(if1, if2)
+impure elemental function ESMF_ifeq(if1, if2)
   logical ESMF_ifeq
   type(ESMF_Index_Flag), intent(in) :: if1, if2
 
   ESMF_ifeq = (if1%i_type == if2%i_type)
 end function
 
-function ESMF_ifneq(if1, if2)
+impure elemental function ESMF_ifneq(if1, if2)
   logical ESMF_ifneq
   type(ESMF_Index_Flag), intent(in) :: if1, if2
 
@@ -1832,7 +1832,7 @@ subroutine ESMF_ifas_string(string, ifval)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_InquireFlag types
 
-function ESMF_inqfeq(inqf1, inqf2)
+impure elemental function ESMF_inqfeq(inqf1, inqf2)
   logical ESMF_inqfeq
   type(ESMF_InquireFlag), intent(in) :: inqf1, inqf2
 
@@ -1842,7 +1842,7 @@ end function ESMF_inqfeq
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_Region_Flag types
 
-function ESMF_rfeq(rf1, rf2)
+impure elemental function ESMF_rfeq(rf1, rf2)
   logical ESMF_rfeq
   type(ESMF_Region_Flag), intent(in) :: rf1, rf2
 
@@ -1862,14 +1862,14 @@ subroutine ESMF_PointerPrint(ptr)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_UNMAPPEDACTION types
 
-function ESMF_unmappedactioneq(uma1, uma2)
+impure elemental function ESMF_unmappedactioneq(uma1, uma2)
  logical ESMF_unmappedactioneq
  type(ESMF_UnmappedAction_Flag), intent(in) :: uma1, uma2
 
  ESMF_unmappedactioneq = (uma1%unmappedaction == uma2%unmappedaction)
 end function
 
-function ESMF_unmappedactionne(uma1, uma2)
+impure elemental function ESMF_unmappedactionne(uma1, uma2)
  logical ESMF_unmappedactionne
  type(ESMF_UnmappedAction_Flag), intent(in) :: uma1, uma2
 
@@ -1880,14 +1880,14 @@ function ESMF_unmappedactionne(uma1, uma2)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_PoleMethod types
 
-function ESMF_RegridPoleEq(rp1, rp2)
+impure elemental function ESMF_RegridPoleEq(rp1, rp2)
  logical ESMF_RegridPoleEq
  type(ESMF_PoleMethod_Flag), intent(in) :: rp1, rp2
 
  ESMF_RegridPoleEq = (rp1%polemethod == rp2%polemethod)
 end function
 
-function ESMF_RegridPoleNe(rp1, rp2)
+impure elemental function ESMF_RegridPoleNe(rp1, rp2)
  logical ESMF_RegridPoleNe
  type(ESMF_PoleMethod_Flag), intent(in) :: rp1, rp2
 
@@ -1897,7 +1897,7 @@ function ESMF_RegridPoleNe(rp1, rp2)
 !------------------------------------------------------------------------------
 #undef  ESMF_METHOD
 #define ESMF_METHOD "ESMF_FileFormatEq"
-function ESMF_FileFormatEq(FileFormat1, FileFormat2)
+impure elemental function ESMF_FileFormatEq(FileFormat1, FileFormat2)
 
 ! !RETURN VALUE:
       logical :: ESMF_FileFormatEq
@@ -1915,7 +1915,7 @@ end function ESMF_FileFormatEq
 !------------------------------------------------------------------------------
 #undef  ESMF_METHOD
 #define ESMF_METHOD "ESMF_FileFormatNe"
- function ESMF_FileFormatNe(FileFormat1, FileFormat2)
+ impure elemental function ESMF_FileFormatNe(FileFormat1, FileFormat2)
 
 ! !RETURN VALUE:
       logical :: ESMF_FileFormatNe
@@ -1965,7 +1965,7 @@ end subroutine ESMF_FileFormatAsString
 !------------------------------------------------------------------------------
 #undef  ESMF_METHOD
 #define ESMF_METHOD "ESMF_FileModeEq"
-function ESMF_FileModeEq(FileMode1, FileMode2)
+impure elemental function ESMF_FileModeEq(FileMode1, FileMode2)
 
   logical :: ESMF_FileModeEq
 
@@ -1977,7 +1977,7 @@ end function ESMF_FileModeEq
 !------------------------------------------------------------------------------
 #undef  ESMF_METHOD
 #define ESMF_METHOD "ESMF_FileModeNe"
-function ESMF_FileModeNe(FileMode1, FileMode2)
+impure elemental function ESMF_FileModeNe(FileMode1, FileMode2)
 
   logical :: ESMF_FileModeNe
 
@@ -1998,14 +1998,14 @@ subroutine ESMF_FileStatusAs(fs1, fs2)
  fs1%status_type = fs2%status_type
 end subroutine ESMF_FileStatusAs
 
-function ESMF_FileStatusEq(fs1, fs2)
+impure elemental function ESMF_FileStatusEq(fs1, fs2)
   logical ESMF_FileStatusEq
   type(ESMF_FileStatus_Flag), intent(in) :: fs1, fs2
 
   ESMF_FileStatusEq = (fs1%status_type == fs2%status_type)
 end function ESMF_FileStatusEq
 
-function ESMF_FileStatusNe(fs1, fs2)
+impure elemental function ESMF_FileStatusNe(fs1, fs2)
   logical ESMF_FileStatusNe
   type(ESMF_FileStatus_Flag), intent(in) :: fs1, fs2
 
@@ -2015,14 +2015,14 @@ end function ESMF_FileStatusNe
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_RegridMethod types
 
-function ESMF_RegridMethodEq(rp1, rp2)
+impure elemental function ESMF_RegridMethodEq(rp1, rp2)
  logical ESMF_RegridMethodEq
  type(ESMF_RegridMethod_Flag), intent(in) :: rp1, rp2
 
  ESMF_RegridMethodEq = (rp1%regridmethod == rp2%regridmethod)
 end function
 
-function ESMF_RegridMethodNe(rp1, rp2)
+impure elemental function ESMF_RegridMethodNe(rp1, rp2)
  logical ESMF_RegridMethodNe
  type(ESMF_RegridMethod_Flag), intent(in) :: rp1, rp2
 
@@ -2032,14 +2032,14 @@ function ESMF_RegridMethodNe(rp1, rp2)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_ExtrapMethod types
 
-function ESMF_ExtrapMethodEq(ep1, ep2)
+impure elemental function ESMF_ExtrapMethodEq(ep1, ep2)
  logical ESMF_ExtrapMethodEq
  type(ESMF_ExtrapMethod_Flag), intent(in) :: ep1, ep2
 
  ESMF_ExtrapMethodEq = (ep1%extrapmethod == ep2%extrapmethod)
 end function
 
-function ESMF_ExtrapMethodNe(ep1, ep2)
+impure elemental function ESMF_ExtrapMethodNe(ep1, ep2)
  logical ESMF_ExtrapMethodNe
  type(ESMF_ExtrapMethod_Flag), intent(in) :: ep1, ep2
 
@@ -2054,7 +2054,7 @@ function ESMF_ExtrapMethodNe(ep1, ep2)
 ! !IROUTINE: ESMF_CoordSysEqual - Equality of Coordinate Systems
 !
 ! !INTERFACE:
-      function ESMF_CoordSysEqual(CoordSys1, CoordSys2)
+      impure elemental function ESMF_CoordSysEqual(CoordSys1, CoordSys2)
 
 ! !RETURN VALUE:
       logical :: ESMF_CoordSysEqual
@@ -2088,7 +2088,7 @@ end function ESMF_CoordSysEqual
 ! !IROUTINE: ESMF_CoordSysNotEqual - Non-equality of CoordSys statuses
 !
 ! !INTERFACE:
-      function ESMF_CoordSysNotEqual(CoordSys1, CoordSys2)
+      impure elemental function ESMF_CoordSysNotEqual(CoordSys1, CoordSys2)
 
 ! !RETURN VALUE:
       logical :: ESMF_CoordSysNotEqual
@@ -2125,7 +2125,7 @@ end function ESMF_CoordSysNotEqual
 ! !IROUTINE: ESMF_NormTypeEqual - Equality of Coordinate Systems
 !
 ! !INTERFACE:
-      function ESMF_NormTypeEqual(NormType1, NormType2)
+      impure elemental function ESMF_NormTypeEqual(NormType1, NormType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_NormTypeEqual
@@ -2159,7 +2159,7 @@ end function ESMF_NormTypeEqual
 ! !IROUTINE: ESMF_NormTypeNotEqual - Non-equality of NormType statuses
 !
 ! !INTERFACE:
-      function ESMF_NormTypeNotEqual(NormType1, NormType2)
+      impure elemental function ESMF_NormTypeNotEqual(NormType1, NormType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_NormTypeNotEqual
@@ -2195,7 +2195,7 @@ end function ESMF_NormTypeNotEqual
 ! !IROUTINE: ESMF_LineTypeEqual - Equality of Coordinate Systems
 !
 ! !INTERFACE:
-      function ESMF_LineTypeEqual(LineType1, LineType2)
+      impure elemental function ESMF_LineTypeEqual(LineType1, LineType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_LineTypeEqual
@@ -2229,7 +2229,7 @@ end function ESMF_LineTypeEqual
 ! !IROUTINE: ESMF_LineTypeNotEqual - Non-equality of LineType statuses
 !
 ! !INTERFACE:
-      function ESMF_LineTypeNotEqual(LineType1, LineType2)
+      impure elemental function ESMF_LineTypeNotEqual(LineType1, LineType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_LineTypeNotEqual
@@ -2265,7 +2265,7 @@ end function ESMF_LineTypeNotEqual
 ! !IROUTINE: ESMF_RWGCheckMethodEqual - Check equality of RWGCheckMethod flags.
 !
 ! !INTERFACE:
-      function ESMF_RWGCheckMethodEqual(CheckMethod1, CheckMethod2)
+      impure elemental function ESMF_RWGCheckMethodEqual(CheckMethod1, CheckMethod2)
 
 ! !RETURN VALUE:
       logical :: ESMF_RWGCheckMethodEqual
@@ -2299,7 +2299,7 @@ end function ESMF_RWGCheckMethodEqual
 ! !IROUTINE: ESMF_RWGCheckMethodNotEqual - Check equality of RWGCheckMethod flags.
 !
 ! !INTERFACE:
-      function ESMF_RWGCheckMethodNotEqual(CheckMethod1, CheckMethod2)
+      impure elemental function ESMF_RWGCheckMethodNotEqual(CheckMethod1, CheckMethod2)
 
 ! !RETURN VALUE:
       logical :: ESMF_RWGCheckMethodNotEqual
@@ -2335,7 +2335,7 @@ end function ESMF_RWGCheckMethodNotEqual
 ! !IROUTINE: ESMF_TermOrderEq - Equality of TermOrder Flag
 !
 ! !INTERFACE:
-      function ESMF_TermOrderEq(termOrder1, termOrder2)
+      impure elemental function ESMF_TermOrderEq(termOrder1, termOrder2)
 
 ! !RETURN VALUE:
       logical :: ESMF_TermOrderEq
diff --git a/src/Infrastructure/VM/interface/ESMF_VM.F90 b/src/Infrastructure/VM/interface/ESMF_VM.F90
index add5ae9a98..53a931a51d 100644
--- a/src/Infrastructure/VM/interface/ESMF_VM.F90
+++ b/src/Infrastructure/VM/interface/ESMF_VM.F90
@@ -1023,7 +1023,7 @@ subroutine c_ESMC_VMSendRecvNB(vm, sendData, sendSize, dst, recvData, &
 ! !IROUTINE:  ESMF_VMEQ - Compare two VMs for equality
 !
 ! !INTERFACE:
-  function ESMF_VMEQ(vm1, vm2)
+  impure elemental function ESMF_VMEQ(vm1, vm2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_VMEQ
@@ -1074,7 +1074,7 @@ end function ESMF_VMEQ
 ! !IROUTINE:  ESMF_VMNE - Compare two VMs for non-equality
 !
 ! !INTERFACE:
-  function ESMF_VMNE(vm1, vm2)
+  impure elemental function ESMF_VMNE(vm1, vm2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_VMNE
diff --git a/src/Infrastructure/XGrid/src/ESMF_XGrid.F90 b/src/Infrastructure/XGrid/src/ESMF_XGrid.F90
index b226026a1e..123b7dfcb1 100644
--- a/src/Infrastructure/XGrid/src/ESMF_XGrid.F90
+++ b/src/Infrastructure/XGrid/src/ESMF_XGrid.F90
@@ -271,7 +271,7 @@ module ESMF_XGridMod
 ! !IROUTINE:  ESMF_XGridEQ - Compare two XGrids for equality
 !
 ! !INTERFACE:
-  function ESMF_XGridEQ(xgrid1, xgrid2)
+  impure elemental function ESMF_XGridEQ(xgrid1, xgrid2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_XGridEQ
@@ -322,7 +322,7 @@ end function ESMF_XGridEQ
 ! !IROUTINE:  ESMF_XGridNE - Compare two XGrids for non-equality
 !
 ! !INTERFACE:
-  function ESMF_XGridNE(xgrid1, xgrid2)
+  impure elemental function ESMF_XGridNE(xgrid1, xgrid2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_XGridNE
@@ -1416,7 +1416,7 @@ end subroutine ESMF_XGridInitialize
 ! !IROUTINE: ESMF_XGridSideEqual - Equality of XGridSides
 !
 ! !INTERFACE:
-      function ESMF_XGridSideEqual(XGridSide1, XGridSide2)
+      impure elemental function ESMF_XGridSideEqual(XGridSide1, XGridSide2)
 
 ! !RETURN VALUE:
       logical :: ESMF_XGridSideEqual
@@ -1450,7 +1450,7 @@ end function ESMF_XGridSideEqual
 ! !IROUTINE: ESMF_XGridSideNotEqual - Non-equality of XGridSides
 !
 ! !INTERFACE:
-      function ESMF_XGridSideNotEqual(XGridSide1, XGridSide2)
+      impure elemental function ESMF_XGridSideNotEqual(XGridSide1, XGridSide2)
 
 ! !RETURN VALUE:
       logical :: ESMF_XGridSideNotEqual
diff --git a/src/Infrastructure/XGridGeomBase/src/ESMF_XGridGeomBase.F90 b/src/Infrastructure/XGridGeomBase/src/ESMF_XGridGeomBase.F90
index 1ccf7d9c97..ec2fb8fc6d 100644
--- a/src/Infrastructure/XGridGeomBase/src/ESMF_XGridGeomBase.F90
+++ b/src/Infrastructure/XGridGeomBase/src/ESMF_XGridGeomBase.F90
@@ -1282,7 +1282,7 @@ end function ESMF_XGridGeomBaseGetInit
 ! !IROUTINE: ESMF_XGridGeomTypeEqual - Equality of GeomTypes
 !
 ! !INTERFACE:
-      function ESMF_XGridGeomTypeEqual(GeomType1, GeomType2)
+      impure elemental function ESMF_XGridGeomTypeEqual(GeomType1, GeomType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_XGridGeomTypeEqual
@@ -1316,7 +1316,7 @@ end function ESMF_XGridGeomTypeEqual
 ! !IROUTINE: ESMF_XGridGeomTypeNotEqual - Non-equality of GeomTypes
 !
 ! !INTERFACE:
-      function ESMF_XGridGeomTypeNotEqual(GeomType1, GeomType2)
+      impure elemental function ESMF_XGridGeomTypeNotEqual(GeomType1, GeomType2)
 
 ! !RETURN VALUE:
       logical :: ESMF_XGridGeomTypeNotEqual
diff --git a/src/Superstructure/Component/src/ESMF_Comp.F90 b/src/Superstructure/Component/src/ESMF_Comp.F90
index 2df69557e1..9e1400cd92 100644
--- a/src/Superstructure/Component/src/ESMF_Comp.F90
+++ b/src/Superstructure/Component/src/ESMF_Comp.F90
@@ -511,13 +511,13 @@ end subroutine ESMF_CompClassValidate
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_Method derived types to see if they're the same 
 
-  function ESMF_meeq(me1, me2)
+  impure elemental function ESMF_meeq(me1, me2)
     logical ESMF_meeq
     type(ESMF_Method_Flag), intent(in) :: me1, me2
     ESMF_meeq = (me1%method == me2%method)    
   end function
 
-  function ESMF_mene(me1, me2)
+  impure elemental function ESMF_mene(me1, me2)
     logical ESMF_mene
     type(ESMF_Method_Flag), intent(in) :: me1, me2
     ESMF_mene = (me1%method /= me2%method)
@@ -528,13 +528,13 @@ function ESMF_mene(me1, me2)
 !------------------------------------------------------------------------------
 ! function to compare two ESMF_CompType_Flags to see if they're the same 
 
-  function ESMF_cteq(ct1, ct2)
+  impure elemental function ESMF_cteq(ct1, ct2)
     logical ESMF_cteq
     type(ESMF_CompType_Flag), intent(in) :: ct1, ct2
     ESMF_cteq = (ct1%ctype == ct2%ctype)    
   end function
 
-  function ESMF_ctne(ct1, ct2)
+  impure elemental function ESMF_ctne(ct1, ct2)
     logical ESMF_ctne
     type(ESMF_CompType_Flag), intent(in) :: ct1, ct2
     ESMF_ctne = (ct1%ctype /= ct2%ctype)
diff --git a/src/Superstructure/Component/src/ESMF_CplComp.F90 b/src/Superstructure/Component/src/ESMF_CplComp.F90
index 4ffb26893e..a33ed586c7 100644
--- a/src/Superstructure/Component/src/ESMF_CplComp.F90
+++ b/src/Superstructure/Component/src/ESMF_CplComp.F90
@@ -269,7 +269,7 @@ module ESMF_CplCompMod
 ! !IROUTINE:  ESMF_CplCompEQ - Compare two CplComps for equality
 !
 ! !INTERFACE:
-  function ESMF_CplCompEQ(cplcomp1, cplcomp2)
+  impure elemental function ESMF_CplCompEQ(cplcomp1, cplcomp2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_CplCompEQ
@@ -320,7 +320,7 @@ end function ESMF_CplCompEQ
 ! !IROUTINE:  ESMF_CplCompNE - Compare two CplComps for non-equality
 !
 ! !INTERFACE:
-  function ESMF_CplCompNE(cplcomp1, cplcomp2)
+  impure elemental function ESMF_CplCompNE(cplcomp1, cplcomp2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_CplCompNE
diff --git a/src/Superstructure/Component/src/ESMF_GridComp.F90 b/src/Superstructure/Component/src/ESMF_GridComp.F90
index 7b54df5b86..9d5bacdf9c 100644
--- a/src/Superstructure/Component/src/ESMF_GridComp.F90
+++ b/src/Superstructure/Component/src/ESMF_GridComp.F90
@@ -273,7 +273,7 @@ module ESMF_GridCompMod
 ! !IROUTINE:  ESMF_GridCompEQ - Compare two GridComps for equality
 !
 ! !INTERFACE:
-  function ESMF_GridCompEQ(gridcomp1, gridcomp2)
+  impure elemental function ESMF_GridCompEQ(gridcomp1, gridcomp2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_GridCompEQ
@@ -325,7 +325,7 @@ end function ESMF_GridCompEQ
 ! !IROUTINE:  ESMF_GridCompNE - Compare two GridComps for non-equality
 !
 ! !INTERFACE:
-  function ESMF_GridCompNE(gridcomp1, gridcomp2)
+  impure elemental function ESMF_GridCompNE(gridcomp1, gridcomp2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_GridCompNE
diff --git a/src/Superstructure/Component/src/ESMF_SciComp.F90 b/src/Superstructure/Component/src/ESMF_SciComp.F90
index 6e78d98499..115cc1f556 100644
--- a/src/Superstructure/Component/src/ESMF_SciComp.F90
+++ b/src/Superstructure/Component/src/ESMF_SciComp.F90
@@ -209,7 +209,7 @@ module ESMF_SciCompMod
 ! !IROUTINE:  ESMF_SciCompEQ - Compare two SciComps for equality
 !
 ! !INTERFACE:
-  function ESMF_SciCompEQ(scicomp1, scicomp2)
+  impure elemental function ESMF_SciCompEQ(scicomp1, scicomp2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_SciCompEQ
@@ -261,7 +261,7 @@ end function ESMF_SciCompEQ
 ! !IROUTINE:  ESMF_SciCompNE - Compare two SciComps for non-equality
 !
 ! !INTERFACE:
-  function ESMF_SciCompNE(scicomp1, scicomp2)
+  impure elemental function ESMF_SciCompNE(scicomp1, scicomp2)
 ! 
 ! !RETURN VALUE:
     logical :: ESMF_SciCompNE
diff --git a/src/Superstructure/State/src/ESMF_StateAPI.cppF90 b/src/Superstructure/State/src/ESMF_StateAPI.cppF90
index c4e6dd4fe9..5930fd7c30 100644
--- a/src/Superstructure/State/src/ESMF_StateAPI.cppF90
+++ b/src/Superstructure/State/src/ESMF_StateAPI.cppF90
@@ -345,7 +345,7 @@ contains
 ! !IROUTINE:  ESMF_StateEQ - Compare two States for equality
 !
 ! !INTERFACE:
-  function ESMF_StateEQ(state1, state2)
+  impure elemental function ESMF_StateEQ(state1, state2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_StateEQ
@@ -394,7 +394,7 @@ contains
 ! !IROUTINE:  ESMF_StateNE - Compare two States for non-equality
 !
 ! !INTERFACE:
-  function ESMF_StateNE(state1, state2)
+  impure elemental function ESMF_StateNE(state1, state2)
 !
 ! !RETURN VALUE:
     logical :: ESMF_StateNE
diff --git a/src/Superstructure/State/src/ESMF_StateTypes.F90 b/src/Superstructure/State/src/ESMF_StateTypes.F90
index d6dd6ac8df..b893905b60 100644
--- a/src/Superstructure/State/src/ESMF_StateTypes.F90
+++ b/src/Superstructure/State/src/ESMF_StateTypes.F90
@@ -164,14 +164,14 @@ module ESMF_StateTypesMod
 
 ! functions to compare two ESMF types to see if they're the same or not
 
-function ESMF_oteq(s1, s2)
+impure elemental function ESMF_oteq(s1, s2)
  logical ESMF_oteq
  type(ESMF_StateItem_Flag), intent(in) :: s1, s2
 
  ESMF_oteq = (s1%ot == s2%ot)
 end function
 
-function ESMF_otne(s1, s2)
+impure elemental function ESMF_otne(s1, s2)
  logical ESMF_otne
  type(ESMF_StateItem_Flag), intent(in) :: s1, s2
 
@@ -179,14 +179,14 @@ function ESMF_otne(s1, s2)
 end function
 
 
-function ESMF_imexeq(s1, s2)
+impure elemental function ESMF_imexeq(s1, s2)
  logical ESMF_imexeq
  type(ESMF_StateIntent_Flag), intent(in) :: s1, s2
 
  ESMF_imexeq = (s1%state == s2%state)
 end function
 
-function ESMF_imexne(s1, s2)
+impure elemental function ESMF_imexne(s1, s2)
  logical ESMF_imexne
  type(ESMF_StateIntent_Flag), intent(in) :: s1, s2
 
@@ -195,14 +195,14 @@ function ESMF_imexne(s1, s2)
 
 
 #if ESMF_ENABLE_NEEDED
-function ESMF_needeq(s1, s2)
+impure elemental function ESMF_needeq(s1, s2)
  logical ESMF_needeq
  type(ESMF_NeededFlag), intent(in) :: s1, s2
 
  ESMF_needeq = (s1%needed == s2%needed)
 end function
 
-function ESMF_needne(s1, s2)
+impure elemental function ESMF_needne(s1, s2)
  logical ESMF_needne
  type(ESMF_NeededFlag), intent(in) :: s1, s2
 
@@ -210,14 +210,14 @@ function ESMF_needne(s1, s2)
 end function
 
 
-function ESMF_redyeq(s1, s2)
+impure elemental function ESMF_redyeq(s1, s2)
  logical ESMF_redyeq
  type(ESMF_ReadyFlag), intent(in) :: s1, s2
 
  ESMF_redyeq = (s1%ready == s2%ready)
 end function
 
-function ESMF_redyne(s1, s2)
+impure elemental function ESMF_redyne(s1, s2)
  logical ESMF_redyne
  type(ESMF_ReadyFlag), intent(in) :: s1, s2
 
@@ -225,14 +225,14 @@ function ESMF_redyne(s1, s2)
 end function
 
 
-function ESMF_valideq(s1, s2)
+impure elemental function ESMF_valideq(s1, s2)
  logical ESMF_valideq
  type(ESMF_ValidFlag), intent(in) :: s1, s2
 
  ESMF_valideq = (s1%valid == s2%valid)
 end function
 
-function ESMF_validne(s1, s2)
+impure elemental function ESMF_validne(s1, s2)
  logical ESMF_validne
  type(ESMF_ValidFlag), intent(in) :: s1, s2