anchor.diff:  CHARACTER(LEN=24)         :: STR24 = '  ABCDEFGHIJKLMNO       '
   TYPE(HASHTABLE)           :: HT
     WRITE(6,'("0*** HASHTEST - INTEGER ********")')
  -  WRITE(6,'("     HASH VALUE OF INT1  ",I20,   " = ",I11)')  INT1, CALCULATE_HASH( INT1)
  -  WRITE(6,'("     HASH VALUE OF INT2  ",I20,   " = ",I11)')  INT2, CALCULATE_HASH( INT2)
  -  WRITE(6,'("     HASH VALUE OF INT4  ",I20,   " = ",I11)')  INT4, CALCULATE_HASH( INT4)
  -  WRITE(6,'("     HASH VALUE OF INT8  ",I20,   " = ",I11)')  INT8, CALCULATE_HASH( INT8)
  +  WRITE(6,'("     HASH VALUE OF INT1  ",I20,   " = ",I11)')  INT1, HASHCODE( INT1)
  +  WRITE(6,'("     HASH VALUE OF INT2  ",I20,   " = ",I11)')  INT2, HASHCODE( INT2)
  +  WRITE(6,'("     HASH VALUE OF INT4  ",I20,   " = ",I11)')  INT4, HASHCODE( INT4)
  +  WRITE(6,'("     HASH VALUE OF INT8  ",I20,   " = ",I11)')  INT8, HASHCODE( INT8)
     WRITE(6,'("0*** HASHTEST - REAL    ********")')
  -  WRITE(6,'("     HASH VALUE OF REAL4 ",G20.10," = ",I11)') REAL4, CALCULATE_HASH(REAL4)
  -  WRITE(6,'("     HASH VALUE OF REAL8 ",G20.10," = ",I11)') REAL8, CALCULATE_HASH(REAL8)
  +  WRITE(6,'("     HASH VALUE OF REAL4 ",G20.10," = ",I11)') REAL4, HASHCODE(REAL4)
  +  WRITE(6,'("     HASH VALUE OF REAL8 ",G20.10," = ",I11)') REAL8, HASHCODE(REAL8)
     WRITE(6,'("0*** HASHTEST - STRING  ********")')
  -  WRITE(6,'("     HASH VALUE OF STR12 ",12X,A12," = ",I11)') STR12, CALCULATE_HASH(STR12)
  -  WRITE(6,'("     HASH VALUE OF STR16 ", 8X,A16," = ",I11)') STR16, CALCULATE_HASH(STR16)
  -  WRITE(6,'("     HASH VALUE OF STR20 ", 4X A20," = ",I11)') STR20, CALCULATE_HASH(STR20)
  -  WRITE(6,'("     HASH VALUE OF STR24 ",    A24," = ",I11)') STR24, CALCULATE_HASH(STR24)
  +  WRITE(6,'("     HASH VALUE OF STR12 ",12X,A12," = ",I11)') STR12, HASHCODE(STR12)
  +  WRITE(6,'("     HASH VALUE OF STR16 ", 8X,A16," = ",I11)') STR16, HASHCODE(STR16)
  +  WRITE(6,'("     HASH VALUE OF STR20 ", 4X A20," = ",I11)') STR20, HASHCODE(STR20)
  +  WRITE(6,'("     HASH VALUE OF STR24 ",    A24," = ",I11)') STR24, HASHCODE(STR24)
   
     CALL HASHTABLE_INIT(HT,8,64)
   END PROGRAM HASHTEST
  +
  
positive.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 MODHASH
  IMPLICIT NONE
  PRIVATE
  PUBLIC :: CALCULATE_HASH,HASHTABLE_INSERT_AT
  PUBLIC :: HASHTABLE
  PUBLIC :: HASHTABLE_INIT
  TYPE HASHTABLE
    INTEGER(KIND=4)             :: TABLE_SIZE
    INTEGER(KIND=4)             :: RECORD_SIZE
    INTEGER(KIND=4)             :: RECORD_COUNT
    INTEGER(KIND=4),ALLOCATABLE :: INDICIES(:,:)
    INTEGER(KIND=1),ALLOCATABLE :: RECORDS(:)
  END TYPE HASHTABLE
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4)             :: HASHTABLE_COUNT, HASHTABLES_SIZE
  TYPE(HASHTABLE),ALLOCATABLE :: HASHTABLES(:)
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTERFACE CALCULATE_HASH
    MODULE PROCEDURE CALCULATE_HASH_INT1
    MODULE PROCEDURE CALCULATE_HASH_INT2
    MODULE PROCEDURE CALCULATE_HASH_INT4
    MODULE PROCEDURE CALCULATE_HASH_INT8
    MODULE PROCEDURE CALCULATE_HASH_REAL4
    MODULE PROCEDURE CALCULATE_HASH_REAL8
    MODULE PROCEDURE CALCULATE_HASH_STRING
  END INTERFACE CALCULATE_HASH
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTERFACE HASHTABLE_INSERT_AT
    MODULE PROCEDURE HASHTABLE_INSERT_INT1_AT
  ! MODULE PROCEDURE HASHTABLE_INSERT_INT2_AT
  ! MODULE PROCEDURE HASHTABLE_INSERT_INT4_AT
  ! MODULE PROCEDURE HASHTABLE_INSERT_INT8_AT
  ! MODULE PROCEDURE HASHTABLE_INSERT_REAL4_AT
  ! MODULE PROCEDURE HASHTABLE_INSERT_REAL8_AT
  ! MODULE PROCEDURE HASHTABLE_INSERT_STRING_AT
  END INTERFACE HASHTABLE_INSERT_AT
  ! ---------------------------------------------------------------------------------------------------------------------------------+
                                                             CONTAINS
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  SUBROUTINE HASHTABLE_INSERT_INT1_AT(HTABLE,VALUE)
  TYPE(HASHTABLE),INTENT(INOUT) :: HTABLE
  INTEGER(KIND=1),INTENT(IN)    :: VALUE
  END SUBROUTINE HASHTABLE_INSERT_INT1_AT
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  SUBROUTINE HASHTABLE_INIT(HTABLE, RECORDSIZE, TABLESIZE)
  TYPE(HASHTABLE),INTENT(INOUT) :: HTABLE
  INTEGER(KIND=4),INTENT(IN)    :: RECORDSIZE,TABLESIZE
    HTABLE%TABLE_SIZE   = TABLESIZE
    HTABLE%RECORD_SIZE  = RECORDSIZE
    HTABLE%RECORD_COUNT = 0
    IF (.NOT.ALLOCATED(HTABLE%INDICIES)) ALLOCATE(HTABLE%INDICIES(         3,TABLESIZE))
    IF (.NOT.ALLOCATED(HTABLE%RECORDS))  ALLOCATE( HTABLE%RECORDS(RECORDSIZE*TABLESIZE))
  END SUBROUTINE HASHTABLE_INIT
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION CALCULATE_HASH_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
    CALCULATE_HASH_INT1 = RVALUE
  END FUNCTION CALCULATE_HASH_INT1
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION CALCULATE_HASH_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
    CALCULATE_HASH_INT2 = RVALUE
  END FUNCTION CALCULATE_HASH_INT2
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION CALCULATE_HASH_INT4(VALUE)
  INTEGER(KIND=4),INTENT(IN) :: VALUE
    CALCULATE_HASH_INT4 = VALUE
  END FUNCTION CALCULATE_HASH_INT4
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION CALCULATE_HASH_INT8(VALUE)
  INTEGER(KIND=8),INTENT(IN)   :: VALUE
  INTEGER(KIND=4),DIMENSION(2) :: VALUES
  INTEGER(KIND=8)              :: SETVALUE
  EQUIVALENCE(VALUES,SETVALUE)
    SETVALUE = VALUE
    CALCULATE_HASH_INT8 = IEOR(VALUES(1),VALUES(2))
  END FUNCTION CALCULATE_HASH_INT8
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION CALCULATE_HASH_REAL4(VALUE)
  REAL   (KIND=4),INTENT(IN)   :: VALUE
  INTEGER(KIND=4)              :: IVALUE
    IVALUE=TRANSFER(VALUE,IVALUE)
    CALCULATE_HASH_REAL4 = CALCULATE_HASH_INT4(IVALUE)
  END FUNCTION CALCULATE_HASH_REAL4
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  INTEGER(KIND=4) FUNCTION CALCULATE_HASH_REAL8(VALUE)
  REAL   (KIND=8),INTENT(IN)   :: VALUE
  INTEGER(KIND=8)              :: IVALUE
    IVALUE=TRANSFER(VALUE,IVALUE)
    CALCULATE_HASH_REAL8 = CALCULATE_HASH_INT8(IVALUE)
  END FUNCTION CALCULATE_HASH_REAL8
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  ! CALCULATE_HASH_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.
  
negative.code:   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
    END DO
  ! ---------------------------------------------------------------------------------------------------------------------------------+
  ! If there is a remainder put it into CVALUE LEFT JUSTIFIED.
  