anchor.diff:      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];
  +      _Node<K, V> onlyValueLeft = newarray[0];
         return (onlyValueLeft is _Leaf)
             ? onlyValueLeft
             : new _SubMap<K, V>.ensureOwner(this, owner, newMask, newarray, newSize);
  
positive.code:     int mask = 1 << branch;
      if ((_bitmap & mask) != 0) {
        int index = _popcount(_bitmap & (mask - 1));
        _NodeBase<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,
        V combine(V x, V y), int hash, int depth) {
      assert(size == 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];
        int oldSize = m.length;
        _NodeBase<K, V> newM =
                  m._insertWith(owner, keyValues, size, 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);
        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);
        // 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,
        V combine(V x, V y), int hash, int depth) {
      assert(size == 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);
      } else {
        return new _EmptyMap(owner);
      }
    }
  
    _NodeBase<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];
        int oldSize = m.length;
        _NodeBase<K, V> newm = m._delete(owner, key, hash, depth + 1, missingOk);
        int delta = newm.length - oldSize;
        if (identical(m, newm)) {
          this._length += delta;
  
negative.code:     }
    }
  
    _Node<K, V> _update(_Owner owner, K key, dynamic updateF, int hash, int depth) {
      int branch = (hash >> (depth * 5)) & 0x1f;
      int mask = 1 << branch;
      int index = _popcount(_bitmap & (mask - 1));
      if ((_bitmap & mask) != 0) {
        _Node<K, V> m = _array[index];
        _Node<K, V> newm = m._update(owner, key, updateF, hash, depth + 1);
        if (identical(newm, m)) {
          return this;
        }
        List<_Node<K, V>> newarray = _makeCopyIfNeeded(owner, this._owner, _array);
        newarray[index] = newm;
  
        return new _SubMap.ensureOwner(this, owner, _bitmap, newarray, length);
  