anchor.diff:    toDebugString() => "_EmptyMap()";
   }
   
  -class _Leaf<K, V> extends _NodeBase<K, V> {
  +class _Leaf<K, V> extends _Node<K, V> {
     int _hash;
     LinkedList<Pair<K, V>> _pairs;
   
  -  _Leaf.abc(_Owner owner, this._hash, pairs, int size) : super(owner, size) {
  +  _Leaf.abc(_Owner owner, this._hash, pairs, int kvLength) : super(owner, kvLength) {
       this._pairs = pairs;
  -    assert(size == pairs.length);
  -  }
  -
  -  factory _Leaf.ensureOwner(_Leaf old, _Owner owner, hash, pairs, int size) {
  +    assert(kvLength == pairs.length);
  +  }
  +
  +  factory _Leaf.ensureOwner(_Leaf old, _Owner owner, hash, pairs, int length) {
       if(_ownerEquals(owner, old._owner)) {
         old._pairs = pairs;
         old._hash = hash;
  -      old._length = size;
  +      old._length = length;
         return old;
       }
  -    return new _Leaf.abc(owner, hash, pairs, size);
  -  }
  -
  -  _NodeBase<K, V> _insertWith(_Owner owner, LinkedList<Pair<K, V>> keyValues, int size,
  +    return new _Leaf.abc(owner, hash, pairs, length);
  +  }
  +
  +  _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);
       // newsize is incremented as a side effect of insertPair
       int newsize = length;
   
  
positive.code:     if (newarray.length > 1) {
        return new _SubMap<K, V>.ensureOwner(this, owner, newMask, newarray, newSize);
      } else if (newarray.length == 1) {
        _NodeBase<K, V> onlyValueLeft = newarray[0];
        return (onlyValueLeft is _Leaf)
            ? onlyValueLeft
            : new _SubMap<K, V>.ensureOwner(this, owner, newMask, newarray, newSize);
  
negative.code:     }
    }
  
    _Node<K, V>
        _unionWith(_Owner owner, _Node<K, V> m, V combine(V x, V y), int depth) =>
            m._unionWithSubMap(owner, this, combine, depth);
  
    _Node<K, V>
        _unionWithEmptyMap(_Owner owner, _EmptyMap<K, V> m, V combine(V x, V y), int depth) =>
            this;
  
    _Node<K, V>
        _unionWithLeaf(_Owner owner, _Leaf<K, V> m, V combine(V x, V y), int depth) =>
            this._insertWith(owner, m._pairs, m.length, (V v1, V v2) => combine(v2, v1),
                m._hash, depth);
  
    _Node<K, V>
        _unionWithSubMap(_Owner owner, _SubMap<K, V> m, V combine(V x, V y), int depth) {
      int ormap = _bitmap | m._bitmap;
      int andmap = _bitmap & m._bitmap;
      List<_Node<K, V>> newarray =
          new List<_Node<K, V>>(_popcount(ormap));
      int mask = 1, i = 0, i1 = 0, i2 = 0;
      int newSize = 0;
      while (mask <= ormap) {
        if ((andmap & mask) != 0) {
          _array[i1];
          m._array[i2];
          _Node<K, V> newMap =
              m._array[i2]._unionWith(owner, _array[i1], combine, depth + 1);
          newarray[i] = newMap;
          newSize += newMap.length;
  