anchor.diff:    DO I = ISTART,IEND-IREM,4
       CVALUE = VALUE(I:I+3)
       IVALUE = IEOR(IVALUE,JVALUE)
  -    WRITE(0,'(I4,X,A4,X,I16)') I,CVALUE,IVALUE
  +!   WRITE(0,'(I4,X,A4,X,I16)') I,CVALUE,IVALUE
     END DO
   ! ---------------------------------------------------------------------------------------------------------------------------------+
   ! If there is a remainder put it into CVALUE LEFT JUSTIFIED.
  
positive.code:   IF (IREM.GT.0) THEN
      CVALUE = VALUE(I:I+IREM-1)
      IVALUE = IEOR(IVALUE,JVALUE)
      WRITE(0,'(I4,X,A4,X,I16)') I,CVALUE,IVALUE
    END IF
    CALCULATE_HASH_STRING = IVALUE
  END FUNCTION CALCULATE_HASH_STRING
  !
  END MODULE MODHASH
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  PROGRAM HASHTEST
  USE MODHASH
  IMPLICIT NONE
  INTEGER(KIND=1),PARAMETER :: IDIV = 11
  INTEGER(KIND=1)           :: INT1 = HUGE(INT1) / IDIV
  
negative.code: ! LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  ! CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  ! ---------------------------------------------------------------------------------------------------------------------------------+
                                                        MODULE MODHASHCODE
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  IMPLICIT NONE
  PRIVATE
  PUBLIC :: HASHCODE
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTERFACE HASHCODE
    MODULE PROCEDURE HASHCODE_INT1
    MODULE PROCEDURE HASHCODE_INT2
    MODULE PROCEDURE HASHCODE_INT4
    MODULE PROCEDURE HASHCODE_INT8
    MODULE PROCEDURE HASHCODE_REAL4
    MODULE PROCEDURE HASHCODE_REAL8
    MODULE PROCEDURE HASHCODE_STRING
  END INTERFACE HASHCODE
  ! ---------------------------------------------------------------------------------------------------------------------------------+
                                                             CONTAINS
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION HASHCODE_INT1(VALUE)
  INTEGER(KIND=1),INTENT(IN)   :: VALUE
  INTEGER(KIND=1),DIMENSION(4) :: VALUES
  INTEGER(KIND=4)              :: RVALUE = 0
  EQUIVALENCE(VALUES,RVALUE)
    VALUES(1) = VALUE
    HASHCODE_INT1 = RVALUE
  END FUNCTION HASHCODE_INT1
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION HASHCODE_INT2(VALUE)
  INTEGER(KIND=2),INTENT(IN)   :: VALUE
  INTEGER(KIND=2),DIMENSION(2) :: VALUES
  INTEGER(KIND=4)              :: RVALUE = 0
  EQUIVALENCE(VALUES,RVALUE)
    VALUES(1) = VALUE
    HASHCODE_INT2 = RVALUE
  END FUNCTION HASHCODE_INT2
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION HASHCODE_INT4(VALUE)
  INTEGER(KIND=4),INTENT(IN) :: VALUE
    HASHCODE_INT4 = VALUE
  END FUNCTION HASHCODE_INT4
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION HASHCODE_INT8(VALUE)
  INTEGER(KIND=8),INTENT(IN)   :: VALUE
  INTEGER(KIND=4),DIMENSION(2) :: VALUES
  INTEGER(KIND=8)              :: SETVALUE
  EQUIVALENCE(VALUES,SETVALUE)
    SETVALUE = VALUE
    HASHCODE_INT8 = IEOR(VALUES(1),VALUES(2))
  END FUNCTION HASHCODE_INT8
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION HASHCODE_REAL4(VALUE)
  REAL   (KIND=4),INTENT(IN)   :: VALUE
  INTEGER(KIND=4)              :: IVALUE
    IVALUE=TRANSFER(VALUE,IVALUE)
    HASHCODE_REAL4 = HASHCODE_INT4(IVALUE)
  END FUNCTION HASHCODE_REAL4
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION HASHCODE_REAL8(VALUE)
  REAL   (KIND=8),INTENT(IN)   :: VALUE
  INTEGER(KIND=8)              :: IVALUE
    IVALUE=TRANSFER(VALUE,IVALUE)
    HASHCODE_REAL8 = HASHCODE_INT8(IVALUE)
  END FUNCTION HASHCODE_REAL8
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  ! HASHCODE_STRING
  !
  ! This subroutine will loop through in 4-byte words calculating the hashcode and IEOR (XOR) it with a running hashcode. This is done
  ! ignoring leading and trailing space characters.
  