anchor.diff:    bool operator ==(ImmutableMap<K,V> other) {
       if (this === other) return true;
       if (other is! _SubMap) return false;
  -    if (_submap.length != other._submap.length) return false;
  -    try {
  -      _submap.forEach((int k, _AImmutableMap<K,V> v) {
  -        if (!other._submap.containsKey(k)) throw new _Stop();
  -        if (other._submap[k] != v) throw new _Stop();
  -      });
  -    } catch (_Stop e) {
  -      return false;
  +    for (int i = 0; i < 32; i++) {
  +      _AImmutableMap<K,V> mi = _submap[i];
  +      _AImmutableMap<K,V> omi = other._submap[i];
  +      if (mi != omi) {
  +        return false;
  +      }
       }
       return true;
     }
  
positive.code: 
    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);
          } else {
            newsubmap[key] = _submap[key];
          }
        } 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);
      });
      return new _SubMap(newsubmap);
    }
  
    forEach(f(K,V)) {
      _submap.forEach((int _, _AImmutableMap<K,V> m) => m.forEach(f));
    }
  
    int size() {
      if (_size == null) {
        _size = 0;
        _submap.forEach((int _, _AImmutableMap<K,V> m) { _size += m.size(); });
      }
      return _size;
    }
  
negative.code:       new LList<Pair<K,V>>.cons(new Pair<K,V>(key, value),
            new LList<Pair<K,V>>.nil());
  
    ImmutableMap<K,V> _makeFromSubMap(List<_AImmutableMap<K,V>> _submap) {
      assert (_submap.length >= 1);
      if (_submap.length > 1) return new _SubMap(_submap);
      else {
        _AImmutableMap<K,V> onlyValueLeft = null;
        int index = 0;
        for (int i = 0; onlyValueLeft === null; i++) {
          onlyValueLeft = _submap[i];
        }
        return onlyValueLeft._isLeaf() ? onlyValueLeft : new _SubMap(_submap);
      }
    }
  