anchor.diff:    }
   
     void operator []=(K key, V value) {
  -    int hashCode = identityHashCode(key);
  -    List buckets = _buckets;
  -    int length = buckets.length;
  -    int index = hashCode & (length - 1);
  -    _HashMapEntry entry = buckets[index];
  +    final hashCode = identityHashCode(key);
  +    final buckets = _buckets;
  +    final length = buckets.length;
  +    final index = hashCode & (length - 1);
  +    var entry = buckets[index];
       while (entry != null) {
         if (hashCode == entry.hashCode && identical(entry.key, key)) {
           entry.value = value;
  
positive.code:   }
  }
  
  abstract class _HashMapIterator<E> implements Iterator<E> {
    final HashMap _map;
    final int _stamp;
  
    int _index = 0;
    _HashMapEntry _entry;
  
    _HashMapIterator(HashMap map)
        : _map = map,
          _stamp = map._modificationCount;
  
    bool moveNext() {
      if (_stamp != _map._modificationCount) {
        throw new ConcurrentModificationError(_map);
      }
      _HashMapEntry entry = _entry;
      if (entry != null) {
        _HashMapEntry next = entry.next;
        if (next != null) {
          _entry = next;
          return true;
        }
        _entry = null;
      }
      List buckets = _map._buckets;
      int length = buckets.length;
      for (int i = _index; i < length; i++) {
        entry = buckets[i];
        if (entry != null) {
  
negative.code:     return value;
    }
  
    V remove(Object key) {
      if (!_validKey(key)) return null;
      final hashCode = _hashCode(key);
      final buckets = _buckets;
      final index = hashCode & (buckets.length - 1);
      var entry = buckets[index];
      _HashMapEntry<K, V> previous = null;
      while (entry != null) {
        final next = entry.next;
        if (hashCode == entry.hashCode && _equals(entry.key, key)) {
          _removeEntry(entry, previous, index);
          _elementCount--;
  