anchor.diff:      int mask = 1 << branch;
       if ((_bitmap & mask) != 0) {
         int index = _popcount(_bitmap & (mask - 1));
  -      _NodeBase<K, V> map = _array[index];
  +      _Node<K, V> map = _array[index];
         return map._get(key, hash, depth + 1);
       } else {
         return _none;
       }
     }
   
  -  _NodeBase<K, V> _insertWith(_Owner owner, LinkedList<Pair<K, V>> keyValues, int size,
  +  _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);
  +    assert(kvLength == keyValues.length);
   
       int branch = (hash >> (depth * 5)) & 0x1f;
       int mask = 1 << branch;
       int index = _popcount(_bitmap & (mask - 1));
   
       if ((_bitmap & mask) != 0) {
  -      _NodeBase<K, V> m = _array[index];
  +      _Node<K, V> m = _array[index];
         int oldSize = m.length;
  -      _NodeBase<K, V> newM =
  -                m._insertWith(owner, keyValues, size, combine, hash, depth + 1);
  +      _Node<K, V> newM =
  +                m._insertWith(owner, keyValues, kvLength, combine, hash, depth + 1);
         if(identical(m, newM)) {
           if(oldSize != m.length) this._length += m.length - oldSize;
           return this;
         }
  -      List<_NodeBase<K, V>> newarray = _makeCopyIfNeeded(owner, this._owner, _array);
  +      List<_Node<K, V>> newarray = _makeCopyIfNeeded(owner, this._owner, _array);
         newarray[index] = newM;
         int delta = newM.length - oldSize;
         return new _SubMap<K, V>.ensureOwner(this, owner, _bitmap, newarray, length + delta);
       } else {
         int newlength = _array.length + 1;
  -      List<_NodeBase<K, V>> newarray =
  -          new List<_NodeBase<K, V>>(newlength);
  +      List<_Node<K, V>> newarray =
  +          new List<_Node<K, V>>(newlength);
         // TODO: find out if there's a "copy array" native function somewhere
         for (int i = 0; i < index; i++) { newarray[i] = _array[i]; }
         for (int i = index; i < newlength - 1; i++) { newarray[i+1] = _array[i]; }
  -      newarray[index] = new _Leaf<K, V>.abc(owner, hash, keyValues, size);
  -      return new _SubMap<K, V>.ensureOwner(this, owner, _bitmap | mask, newarray, length + size);
  -    }
  -  }
  -
  -  _NodeBase<K, V> _intersectWith(_Owner owner, LinkedList<Pair<K, V>> keyValues, int size,
  +      newarray[index] = new _Leaf<K, V>.abc(owner, hash, keyValues, kvLength);
  +      return new _SubMap<K, V>.ensureOwner(this, owner, _bitmap | mask, newarray, length + 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);
   
       int branch = (hash >> (depth * 5)) & 0x1f;
       int mask = 1 << branch;
   
       if ((_bitmap & mask) != 0) {
         int index = _popcount(_bitmap & (mask - 1));
  -      _NodeBase<K, V> m = _array[index];
  -      return m._intersectWith(owner, keyValues, size, combine, hash, depth + 1);
  +      _Node<K, V> m = _array[index];
  +      return m._intersectWith(owner, keyValues, kvLength, combine, hash, depth + 1);
       } else {
         return new _EmptyMap(owner);
       }
     }
   
  -  _NodeBase<K, V> _delete(owner, K key, int hash, int depth, bool missingOk) {
  +  _Node<K, V> _delete(owner, K key, int hash, int depth, bool missingOk) {
       int branch = (hash >> (depth * 5)) & 0x1f;
       int mask = 1 << branch;
   
       if ((_bitmap & mask) != 0) {
         int index = _popcount(_bitmap & (mask - 1));
  -      _NodeBase<K, V> m = _array[index];
  +      _Node<K, V> m = _array[index];
         int oldSize = m.length;
  -      _NodeBase<K, V> newm = m._delete(owner, key, hash, depth + 1, missingOk);
  +      _Node<K, V> newm = m._delete(owner, key, hash, depth + 1, missingOk);
         int delta = newm.length - oldSize;
         if (identical(m, newm)) {
           this._length += delta;
  
positive.code: 
    void forEachKeyValue(f(K key, V value));
  
    _NodeBase mapValues(_Owner owner, f(V value));
  
  }
  
  
negative.code: }
  
  abstract class _ReadMapImpl<K, V> extends IterableBase<Pair<K, V>> {
    _Node _root;
  
    V get(K key, [V notFound = _none]) {
      var val = _root.get(key);
  