anchor.diff:              type(hash_table_t), intent(inout) :: ht
               integer, intent(out) :: indx
   
  -            indx = ht%free_elements(ht%next_free_element)
  -            ht%free_elements(ht%next_free_element) = 0
  -            ht%next_free_element = modulo(ht%next_free_element-1,ht%max_free_reqd)
  +            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
  
positive.code: 
          ! 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
          ! 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
          ! structure.
  
          ! Highest occupied element 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
          ! entry in data_label and payload arrays.
          integer :: next_free_element
          ! Circular array.  Non-zero elements correspond to free elements in the
          ! data_label and corresponding payload arrays.
          integer, allocatable :: free_elements(:) ! (0:max_free_reqd-1)
  
      end type hash_table_t
  
  
negative.code:             ! Reset hash table.
  
              ! In/Out:
              !    ht: hash table.  On output the table, head, next_free_entry
              !        and free_entries attributes are all set to 0.  This means
              !        that no data is stored in the hash table and new entries 
              !        are added by consecutively by incrementing head.
  
              type(hash_table_t), intent(inout) :: ht
  