anchor.diff:      return _delegate.toString();
     }
   
  -  Iterable<V> where(bool test(V element)) {
  +  C where(bool test(V element)) {
       _syncDelegate();
       return _delegate.where(test);
     }
   }
   
  -class _WrappedList<K, V> extends _WrappedIterable<K, V> implements List<V> {
  -  _WrappedList(Map<K, Iterable<V>> map, K key, List<V> delegate) :
  +class _WrappedList<K, V>
  +    extends _WrappedIterable<K, V, List<V>>
  +    implements List<V> {
  +  _WrappedList(Map<K, List<V>> map, K key, List<V> delegate) :
         super(map, key, delegate);
   
     V operator [](int index) => elementAt(index);
   
     void operator []=(int index, V value) {
       _syncDelegate();
  -    (_delegate as List)[index] = value;
  +    _delegate[index] = value;
     }
   
     void add(V value) {
       _syncDelegate();
       var wasEmpty = _delegate.isEmpty;
  -    (_delegate as List).add(value);
  +    _delegate.add(value);
       if (wasEmpty) _addToMap();
     }
   
     void addAll(Iterable<V> iterable) {
       _syncDelegate();
       var wasEmpty = _delegate.isEmpty;
  -    (_delegate as List).addAll(iterable);
  +    _delegate.addAll(iterable);
       if (wasEmpty) _addToMap();
     }
   
     Map<int, V> asMap() {
       _syncDelegate();
  -    return (_delegate as List).asMap();
  +    return _delegate.asMap();
     }
   
     void clear() {
       _syncDelegate();
  -    (_delegate as List).clear();
  +    _delegate.clear();
       _map.remove(_key);
     }
   
     void fillRange(int start, int end, [V fillValue]) {
       _syncDelegate();
  -    (_delegate as List).fillRange(start, end, fillValue);
  -  }
  -
  -  Iterable<V> getRange(int start, int end) {
  -    _syncDelegate();
  -    return (_delegate as List).getRange(start, end);
  +    _delegate.fillRange(start, end, fillValue);
  +  }
  +
  +  List<V> getRange(int start, int end) {
  +    _syncDelegate();
  +    return _delegate.getRange(start, end);
     }
   
     int indexOf(V element, [int start = 0]) {
       _syncDelegate();
  -    return (_delegate as List).indexOf(element, start);
  +    return _delegate.indexOf(element, start);
     }
   
     void insert(int index, V element) {
       _syncDelegate();
       var wasEmpty = _delegate.isEmpty;
  -    (_delegate as List).insert(index, element);
  +    _delegate.insert(index, element);
       if (wasEmpty) _addToMap();
     }
   
     void insertAll(int index, Iterable<V> iterable) {
       _syncDelegate();
       var wasEmpty = _delegate.isEmpty;
  -    (_delegate as List).insertAll(index, iterable);
  +    _delegate.insertAll(index, iterable);
       if (wasEmpty) _addToMap();
     }
   
     int lastIndexOf(V element, [int start]) {
       _syncDelegate();
  -    return (_delegate as List).lastIndexOf(element, start);
  +    return _delegate.lastIndexOf(element, start);
     }
   
     void set length(int newLength) {
       _syncDelegate();
       var wasEmpty = _delegate.isEmpty;
  -    (_delegate as List).length = newLength;
  +    _delegate.length = newLength;
       if (wasEmpty) _addToMap();
     }
   
     bool remove(Object value) {
       _syncDelegate();
  -    bool removed = (_delegate as List).remove(value);
  +    bool removed = _delegate.remove(value);
       if (_delegate.isEmpty) _map.remove(_key);
       return removed;
     }
   
     V removeAt(int index) {
       _syncDelegate();
  -    V removed = (_delegate as List).removeAt(index);
  +    V removed = _delegate.removeAt(index);
       if (_delegate.isEmpty) _map.remove(_key);
       return removed;
     }
   
     V removeLast() {
       _syncDelegate();
  -    V removed = (_delegate as List).removeLast();
  +    V removed = _delegate.removeLast();
       if (_delegate.isEmpty) _map.remove(_key);
       return removed;
     }
   
     void removeRange(int start, int end) {
       _syncDelegate();
  -    (_delegate as List).removeRange(start, end);
  +    _delegate.removeRange(start, end);
       if (_delegate.isEmpty) _map.remove(_key);
     }
   
     void removeWhere(bool test(V element)) {
       _syncDelegate();
  -    (_delegate as List).removeWhere(test);
  +    _delegate.removeWhere(test);
       if (_delegate.isEmpty) _map.remove(_key);
     }
   
     void replaceRange(int start, int end, Iterable<V> iterable) {
       _syncDelegate();
  -    (_delegate as List).replaceRange(start, end, iterable);
  +    _delegate.replaceRange(start, end, iterable);
       if (_delegate.isEmpty) _map.remove(_key);
     }
   
     void retainWhere(bool test(V element)) {
       _syncDelegate();
  -    (_delegate as List).retainWhere(test);
  +    _delegate.retainWhere(test);
       if (_delegate.isEmpty) _map.remove(_key);
     }
   
     Iterable<V> get reversed {
       _syncDelegate();
  -    return (_delegate as List).reversed;
  +    return _delegate.reversed;
     }
   
     void setAll(int index, Iterable<V> iterable) {
       _syncDelegate();
  -    (_delegate as List).setAll(index, iterable);
  +    _delegate.setAll(index, iterable);
     }
   
     void setRange(int start, int end, Iterable<V> iterable, [int skipCount = 0]) {
  
positive.code:  * A multimap implementation that uses [List]s to store the values associated
   * with each key.
   */
  class ListMultimap<K, V> extends _BaseMultimap<K, V> {
    ListMultimap() : super();
    List<V> _create() => new List<V>();
    List<V> _wrap(Object key, Iterable<V> iterable) =>
        new _WrappedList(_map, key, iterable);
    List<V> operator [](Object key) => super[key];
    List<V> removeAll(Object key) => super.removeAll(key);
  
negative.code: /**
   * Iterable wrapper that syncs to an underlying map.
   */
  class _WrappedIterable<K, V, C extends Iterable<V>> implements Iterable<V> {
    final K _key;
    final Map<K, C> _map;
    C _delegate;
  
    _WrappedIterable(this._map, this._key, this._delegate);
  
  