anchor.diff:    int _hash;
     LinkedList<Pair<K, V>> _pairs;
   
  -  _Leaf.abc(_Owner owner, this._hash, pairs, int kvLength) : super(owner, kvLength) {
  +  _Leaf.abc(_Owner owner, this._hash, pairs, int pairsLength) : super(owner, pairsLength) {
       this._pairs = pairs;
  -    assert(kvLength == pairs.length);
  +    assert(pairsLength == pairs.length);
     }
   
     factory _Leaf.ensureOwner(_Leaf old, _Owner owner, hash, pairs, int length) {
  
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: 
      if (depth > 5) {
        assert(_hash == hash);
        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(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, 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(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;
      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++;
  