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: }
  
  class _SubMap<K extends Hashable, V> extends _AImmutableMap<K,V> {
    Map<int, _AImmutableMap<K,V>> _submap;
    int _size = null;
  
    _SubMap(this._submap);
  
negative.code: 
    Option<V> _lookup(K key, int hash, int depth) {
      int branch = (hash >> (depth * 5)) & 0x1f;
      if (_submap[branch] !== null) {
        _AImmutableMap<K,V> map = _submap[branch];
        return map._lookup(key, hash, depth + 1);
      } else {
  