anchor.diff:    bool moveNext() => false;
   }
   
  -class _EmptyMap<K, V> extends _NodeBase<K, V> {
  +class _EmptyMap<K, V> extends _Node<K, V> {
     _EmptyMap(_Owner owner) : super(owner, 0);
   
     V _get(K key, int hash, int depth) => _none;
   
  -  _NodeBase<K, V> _insertWith(_Owner owner,
  -      LinkedList<Pair<K, V>> keyValues, int size, V combine(V x, V y), int hash,
  +  _Node<K, V> _insertWith(_Owner owner,
  +      LinkedList<Pair<K, V>> keyValues, int kvLength, V combine(V x, V y), int hash,
         int depth) {
  -    assert(size == keyValues.length);
  -    return new _Leaf<K, V>.abc(owner, hash, keyValues, size);
  -  }
  -
  -  _NodeBase<K, V> _intersectWith(_Owner owner, LinkedList<Pair<K, V>> keyValues, int size,
  +    assert(kvLength == keyValues.length);
  +    return new _Leaf<K, V>.abc(owner, hash, keyValues, kvLength);
  +  }
  +
  +  _Node<K, V> _intersectWith(_Owner owner, LinkedList<Pair<K, V>> keyValues, int kvLength,
         V combine(V x, V y), int hash, int depth) {
  -    assert(size == keyValues.length);
  +    assert(kvLength == keyValues.length);
       return this;
     }
   
  -  _NodeBase<K, V> _delete(_Owner owner, K key, int hash, int depth, bool missingOk) =>
  +  _Node<K, V> _delete(_Owner owner, K key, int hash, int depth, bool missingOk) =>
         missingOk ? this : _ThrowKeyError(key);
   
  -  _NodeBase<K, V> _update(_Owner owner, K key, dynamic updateF, int hash, int depth) =>
  +  _Node<K, V> _update(_Owner owner, K key, dynamic updateF, int hash, int depth) =>
       this.assoc(owner, key, _getUpdateValue(key, updateF));
   
  -  _NodeBase<K, V>
  -      _unionWith(_Owner owner, _NodeBase<K, V> m, V combine(V x, V y), int depth) => m;
  -
  -  _NodeBase<K, V>
  +  _Node<K, V>
  +      _unionWith(_Owner owner, _Node<K, V> m, V combine(V x, V y), int depth) => m;
  +
  +  _Node<K, V>
         _unionWithEmptyMap(_Owner owner, _EmptyMap<K, V> m, V combine(V x, V y), int depth) {
       throw "should never be called";
     }
   
  -  _NodeBase<K, V>
  +  _Node<K, V>
         _unionWithLeaf(_Owner owner, _Leaf<K, V> m, V combine(V x, V y), int depth) => m;
   
  -  _NodeBase<K, V>
  +  _Node<K, V>
         _unionWithSubMap(_Owner owner, _SubMap<K, V> m, V combine(V x, V y), int depth) => m;
   
  -  _NodeBase<K, V>
  -      _intersectionWith(_Owner owner, _NodeBase<K, V> m, V combine(V x, V y),
  +  _Node<K, V>
  +      _intersectionWith(_Owner owner, _Node<K, V> m, V combine(V x, V y),
                           int depth) => this;
   
  -  _NodeBase<K, V>
  +  _Node<K, V>
         _intersectionWithEmptyMap(_Owner owner, _EmptyMap<K, V> m, V combine(V x, V y),
                                   int depth) {
           throw "should never be called";
     }
   
  -  _NodeBase<K, V> _intersectionWithLeaf(_Owner owner,
  +  _Node<K, V> _intersectionWithLeaf(_Owner owner,
         _Leaf<K, V> m, V combine(V x, V y), int depth) => this;
   
  -  _NodeBase<K, V> _intersectionWithSubMap(_Owner owner,
  +  _Node<K, V> _intersectionWithSubMap(_Owner owner,
         _SubMap<K, V> m, V combine(V x, V y), int depth) => this;
   
  -  _NodeBase mapValues(_Owner owner, f(V)) => this;
  +  _Node mapValues(_Owner owner, f(V)) => this;
   
     void forEachKeyValue(f(K, V)) {}
   
  -  bool operator ==(other) => other is _NodeBase ? other is _EmptyMap : false;
  +  bool operator ==(other) => other is _Node ? other is _EmptyMap : false;
   
     Iterator<Pair<K, V>> get iterator => const _EmptyMapIterator();
   
  
positive.code:     }
    }
  
    _NodeBase mapValues(_Owner owner, f(V)) {
      List<_NodeBase<K, V>> newarray = _makeCopyIfNeeded(owner, this._owner, _array);
      for (int i = 0; i < _array.length; i++) {
        _NodeBase<K, V> mi = _array[i];
          newarray[i] = mi.mapValues(owner, f);
      }
      return new _SubMap.ensureOwner(this, owner, _bitmap, newarray, length);
  
negative.code: /**
   * Superclass for _EmptyMap, _Leaf and _SubMap.
   */
  abstract class _Node<K, V> extends IterableBase<Pair<K, V>> {
    _Owner _owner;
  
    int _length;
    get length => _length;
  
    _Node(this._owner, this._length);
  
    V _get(K key, int hash, int depth);
    _Node<K, V> _insertWith(_Owner owner, LinkedList<Pair<K, V>> keyValues, int kvLength,
        V combine(V x, V y), int hash, int depth);
    _Node<K, V> _intersectWith(_Owner owner, LinkedList<Pair<K, V>> keyValues, int kvLength,
        V combine(V x, V y), int hash, int depth);
    _Node<K, V> _delete(_Owner owner, K key, int hash, int depth, bool missingOk);
    _Node<K, V> _update(_Owner owner, K key, dynamic updateF, int hash, int depth);
  
    _Node<K, V>
        _unionWith(_Owner owner, _Node<K, V> m, V combine(V x, V y), int depth);
    _Node<K, V>
        _unionWithEmptyMap(_Owner owner, _EmptyMap<K, V> m, V combine(V x, V y), int depth);
    _Node<K, V>
        _unionWithLeaf(_Owner owner, _Leaf<K, V> m, V combine(V x, V y), int depth);
    _Node<K, V>
        _unionWithSubMap(_Owner owner, _SubMap<K, V> m, V combine(V x, V y), int depth);
  
    _Node<K, V>
        _intersectionWith(_Owner owner, _Node<K, V> m, V combine(V x, V y),
                          int depth);
    _Node<K, V>
        _intersectionWithEmptyMap(_Owner owner, _EmptyMap<K, V> m, V combine(V x, V y),
                                  int depth);
    _Node<K, V>
        _intersectionWithLeaf(_Owner owner, _Leaf<K, V> m, V combine(V x, V y), int depth);
    _Node<K, V>
        _intersectionWithSubMap(_Owner owner, _SubMap<K, V> m, V combine(V x, V y), int depth);
  
    Pair<K, V> _elementAt(int index);
  