anchor.diff:  
           ! We usually want to iterate over the data items, so it is best if they
           ! are (as far as possible) contiguous.
  -        ! If not, we can insert elements into the empty element.  Typically (we
  +        ! If not, we can insert an entry into the empty entry.  Typically (we
           ! hope!) we have more room than the number of items we're actually
           ! storing.  If there are no slots in the occupied section of data_label
  -        ! and payload, then we use the next free element at the head of the data
  +        ! and payload, then we use the next free entry at the head of the data
           ! structure.
   
  -        ! Highest occupied element in the data_label and payload arrays.
  +        ! Highest occupied entry in the data_label and payload arrays.
           integer :: head
   
           ! Maximum number of free slots we might wish to access before iterating
           ! over data_label again (at which point we can easily update the list of
           ! free entries).
           integer :: max_free_reqd
  -        ! The index of the element in free_elements which grants the next free
  +        ! The index of the element in free_entries which grants the next free
           ! entry in data_label and payload arrays.
  -        integer :: next_free_element
  -        ! Circular array.  Non-zero elements correspond to free elements in the
  +        integer :: next_free_entry
  +        ! Circular array.  Non-zero elements correspond to free entries in the
           ! data_label and corresponding payload arrays.
  -        integer, allocatable :: free_elements(:) ! (0:max_free_reqd-1)
  +        integer, allocatable :: free_entries(:) ! (0:max_free_reqd-1)
   
       end type hash_table_t
   
  
positive.code:                 end if
              end do
  
          end subroutine lookup_hash_table_element
  
  !--- Hash table manipulation utilities ---
  
  
negative.code:             type(hash_table_t), intent(inout) :: ht
              integer, intent(out) :: indx
  
              indx = ht%free_entries(ht%next_free_entry)
              ht%free_entries(ht%next_free_entry) = 0
              ht%next_free_entry = modulo(ht%next_free_entry-1,ht%max_free_reqd)
  
              if (indx == 0) then
                  ! Have run out of free slots that we know about in the
  