anchor.diff:  
       if (depth > 5) {
         assert(_hash == hash);
  -      final LinkedList<Pair<K, V>> newPairs = insertPairs(keyValues, _pairs);
  +      final LinkedList<Pair<K, V>> newPairs = insertPairs(pairs, _pairs);
         return new _Leaf<K, V>.ensureOwner(this, owner, hash, newPairs, newsize);
       } else {
         if (hash == _hash) {
  -        final LinkedList<Pair<K, V>> newPairs = insertPairs(keyValues, _pairs);
  +        final LinkedList<Pair<K, V>> newPairs = insertPairs(pairs, _pairs);
           return new _Leaf<K, V>.ensureOwner(this, owner, hash, newPairs, newsize);
         } else {
           int branch = (_hash >> (depth * 5)) & 0x1f;
           List<_Node<K, V>> array = new List.filled(1, this);
           return new _SubMap<K, V>.abc(owner, 1 << branch, array, length)
  -            ._insertWith(owner, keyValues, kvLength, combine, hash, depth);
  -      }
  -    }
  -  }
  -
  -  _Node<K, V> _intersectWith(_Owner owner, LinkedList<Pair<K, V>> keyValues, int kvLength,
  +            ._insertWith(owner, pairs, pairsLength, combine, hash, depth);
  +      }
  +    }
  +  }
  +
  +  _Node<K, V> _intersectWith(_Owner owner, LinkedList<Pair<K, V>> pairs, int pairsLength,
         V combine(V x, V y), int hash, int depth) {
  -    assert(kvLength == keyValues.length);
  +    assert(pairsLength == pairs.length);
       // TODO(polux): possibly faster implementation
       Map<K, V> map = toMap();
       LinkedListBuilder<Pair<K, V>> builder = new LinkedListBuilder<Pair<K, V>>();
       int newsize = 0;
  -    keyValues.foreach((Pair<K, V> pair) {
  +    pairs.foreach((Pair<K, V> pair) {
         if (map.containsKey(pair.first)) {
           builder.add(new Pair<K, V>(pair.first, combine(map[pair.first], pair.second)));
           newsize++;
  
positive.code:     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(kvLength == keyValues.length);
      // newsize is incremented as a side effect of insertPair
      int newsize = length;
  
  
negative.code:   _Node(this._owner, this._length);
  
    V _get(K key, int hash, int depth);
    _Node<K, V> _insertWith(_Owner owner, LinkedList<Pair<K, V>> pairs, int pairsLength,
        V combine(V x, V y), int hash, int depth);
    _Node<K, V> _intersectWith(_Owner owner, LinkedList<Pair<K, V>> pairs, int pairsLength,
        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);
  