anchor.diff:  
     ImmutableMap<K,V>
         _unionWithSubMap(_SubMap<K,V> m, V combine(V x, V y), int depth) {
  -    Map<int, _AImmutableMap<K,V>> newsubmap =
  -        new Map<int, _AImmutableMap<K,V>>();
  -    Set<int> allKeys = new Set<int>.from(_submap.getKeys());
  -    allKeys.addAll(m._submap.getKeys());
  -    allKeys.forEach((int key) {
  -      if (_submap.containsKey(key)) {
  -        if (m._submap.containsKey(key)) {
  -          newsubmap[key] =
  -              m._submap[key]._unionWith(_submap[key], combine, depth + 1);
  +    List<_AImmutableMap<K,V>> newsubmap =
  +        new List<_AImmutableMap<K,V>>.from(_submap);
  +    for (int i = 0; i < 32; i++) {
  +      _AImmutableMap<K,V> mi = m._submap[i];
  +      if (mi !== null) {
  +        _AImmutableMap<K,V> mmi = _submap[i];
  +        if (mmi !== null) {
  +          newsubmap[i] = mi._unionWith(mmi, combine, depth + 1);
           } else {
  -          newsubmap[key] = _submap[key];
  +          newsubmap[i] = mi;
           }
  -      } else {
  -        newsubmap[key] = m._submap[key];
  -      }
  -    });
  +      }
  +    }
       return new _SubMap<K,V>(newsubmap);
     }
   
     ImmutableMap mapValues(f(V)) {
  -    Map newsubmap = new Map();
  -    _submap.forEach((int i, _AImmutableMap<K,V> m) {
  -      newsubmap[i] = m.mapValues(f);
  -    });
  +    List<_AImmutableMap<K,V>> newsubmap =
  +        new List<_AImmutableMap<K,V>>.from(_submap);
  +    for (int i = 0; i < 32; i++) {
  +      _AImmutableMap<K,V> mi = _submap[i];
  +      if (mi !== null) {
  +        newsubmap[i] = mi.mapValues(f);
  +      }
  +    }
       return new _SubMap(newsubmap);
     }
   
     forEach(f(K,V)) {
  -    _submap.forEach((int _, _AImmutableMap<K,V> m) => m.forEach(f));
  +    List<_AImmutableMap<K,V>> newsubmap =
  +        new List<_AImmutableMap<K,V>>.from(_submap);
  +    for (int i = 0; i < 32; i++) {
  +      _AImmutableMap<K,V> mi = _submap[i];
  +      if (mi !== null) {
  +        mi.forEach(f);
  +      }
  +    }
     }
   
     int size() {
       if (_size == null) {
         _size = 0;
  -      _submap.forEach((int _, _AImmutableMap<K,V> m) { _size += m.size(); });
  +      for (int i = 0; i < 32; i++) {
  +        _AImmutableMap<K,V> mi = _submap[i];
  +        if (mi !== null) {
  +          _size += mi.size();
  +        }
  +      }
       }
       return _size;
     }
  
positive.code:       new LList<Pair<K,V>>.cons(new Pair<K,V>(key, value),
            new LList<Pair<K,V>>.nil());
  
    ImmutableMap<K,V> _makeFromSubMap(Map<int, _AImmutableMap<K,V>> _submap) {
      assert (_submap.length >= 1);
      if (_submap.length > 1) return new _SubMap(_submap);
      else {
        _AImmutableMap<K,V> onlyValueLeft = null;
        // There's only one value left but that's the only way of getting it
        // without resorting to _submap.getKeys().iterator() and [] which might be
        // even slower.
        _submap.forEach((_, value) { onlyValueLeft = value; });
        assert (onlyValueLeft !== null);
        return onlyValueLeft._isLeaf() ? onlyValueLeft : new _SubMap(_submap);
      }
    }
  
negative.code: 
    ImmutableMap<K,V> _adjust(K key, V update(V), int hash, int depth) {
      int branch = (hash >> (depth * 5)) & 0x1f;
      if (_submap[branch] !== null) {
        _AImmutableMap<K,V> m = _submap[branch];
        _AImmutableMap<K,V> newm = m._adjust(key, update, hash, depth + 1);
        List<_AImmutableMap<K,V>> newsubmap =
            new List<_AImmutableMap<K,V>>.from(_submap);
        newsubmap[branch] = newm;
        return new _SubMap<K,V>(newsubmap);
      } else {
  