implement mixins in subtype checks, more codegen fixes

lib/runtime/dart/collection.js

 var collection;
 (function(exports) {
   'use strict';
   let _source = Symbol('_source');
   let UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
       UnmodifiableListView(source) {
         this[_source] = source;
         super.UnmodifiableListBase();
       }
       get length() {
         return this[_source].length;
       }
       get(index) {
         return this[_source].elementAt(index);
       }
     }
     return UnmodifiableListView;
   });
   dart.defineLazyClassGeneric(exports, 'UnmodifiableListView', {get: UnmodifiableListView$});
   // Function _defaultEquals: (dynamic, dynamic) → bool
   function _defaultEquals(a, b) {
     return dart.equals(a, b);
   }
   // Function _defaultHashCode: (dynamic) → int
   function _defaultHashCode(a) {
     return dart.as(dart.dload(a, 'hashCode'), core.int);
   }
+  let _Equality$ = dart.generic(function(K) {
+    class _Equality extends core.Function {}
+    return _Equality;
+  });
+  let _Equality = _Equality$();
+  let _Hasher$ = dart.generic(function(K) {
+    class _Hasher extends core.Function {}
+    return _Hasher;
+  });
+  let _Hasher = _Hasher$();
   let HashMap$ = dart.generic(function(K, V) {
     class HashMap extends core.Object {
       HashMap(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_HashMap$(K, V))();
@@ skipping 40 matching lines @@
         return map;
       }
     }
     HashMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(HashMap, 'identity');
     dart.defineNamedConstructor(HashMap, 'from');
     dart.defineNamedConstructor(HashMap, 'fromIterable');
     dart.defineNamedConstructor(HashMap, 'fromIterables');
     return HashMap;
   });
-  let HashMap = HashMap$(dart.dynamic, dart.dynamic);
+  let HashMap = HashMap$();
   let _newSet = Symbol('_newSet');
   let SetMixin$ = dart.generic(function(E) {
     class SetMixin extends core.Object {
       get isEmpty() {
         return this.length == 0;
       }
       get isNotEmpty() {
         return this.length != 0;
       }
       clear() {
@@ skipping 227 matching lines @@
           if (index == elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
         throw new core.RangeError.index(index, this, "index", null, elementIndex);
       }
     }
     SetMixin[dart.implements] = () => [core.Set$(E)];
     return SetMixin;
   });
-  let SetMixin = SetMixin$(dart.dynamic);
+  let SetMixin = SetMixin$();
   let SetBase$ = dart.generic(function(E) {
     class SetBase extends SetMixin$(E) {
       static setToString(set) {
         return IterableBase.iterableToFullString(set, '{', '}');
       }
     }
     return SetBase;
   });
-  let SetBase = SetBase$(dart.dynamic);
+  let SetBase = SetBase$();
   let _HashSetBase$ = dart.generic(function(E) {
     class _HashSetBase extends SetBase$(E) {
       difference(other) {
         let result = this[_newSet]();
         for (let element of this) {
           if (!dart.notNull(other.contains(element)))
             result.add(element);
         }
         return result;
       }
       intersection(other) {
         let result = this[_newSet]();
         for (let element of this) {
           if (other.contains(element))
             result.add(element);
         }
         return result;
       }
       toSet() {
         return ((_) => {
           _.addAll(this);
           return _;
         }).bind(this)(this[_newSet]());
       }
     }
     return _HashSetBase;
   });
-  let _HashSetBase = _HashSetBase$(dart.dynamic);
+  let _HashSetBase = _HashSetBase$();
   let HashSet$ = dart.generic(function(E) {
     class HashSet extends core.Object {
       HashSet(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_HashSet$(E))();
@@ skipping 25 matching lines @@
         for (let e of dart.as(elements, core.Iterable$(E)))
           result.add(e);
         return result;
       }
     }
     HashSet[dart.implements] = () => [core.Set$(E)];
     dart.defineNamedConstructor(HashSet, 'identity');
     dart.defineNamedConstructor(HashSet, 'from');
     return HashSet;
   });
-  let HashSet = HashSet$(dart.dynamic);
+  let HashSet = HashSet$();
   let IterableMixin$ = dart.generic(function(E) {
     class IterableMixin extends core.Object {
       map(f) {
         return new (_internal.MappedIterable$(E, dynamic))(this, f);
       }
       where(f) {
         return new (_internal.WhereIterable$(E))(this, f);
       }
       expand(f) {
         return new (_internal.ExpandIterable$(E, dynamic))(this, f);
@@ skipping 175 matching lines @@
         }
         throw new core.RangeError.index(index, this, "index", null, elementIndex);
       }
       toString() {
         return IterableBase.iterableToShortString(this, '(', ')');
       }
     }
     IterableMixin[dart.implements] = () => [core.Iterable$(E)];
     return IterableMixin;
   });
-  let IterableMixin = IterableMixin$(dart.dynamic);
+  let IterableMixin = IterableMixin$();
   let _isToStringVisiting = Symbol('_isToStringVisiting');
   let _toStringVisiting = Symbol('_toStringVisiting');
   let _iterablePartsToStrings = Symbol('_iterablePartsToStrings');
   let IterableBase$ = dart.generic(function(E) {
     class IterableBase extends core.Object {
       IterableBase() {
       }
       map(f) {
         return new (_internal.MappedIterable$(E, dynamic))(this, f);
       }
@@ skipping 314 matching lines @@
       }
     }
     IterableBase[dart.implements] = () => [core.Iterable$(E)];
     dart.defineLazyProperties(IterableBase, {
       get _toStringVisiting() {
         return new core.List.from([]);
       }
     });
     return IterableBase;
   });
-  let IterableBase = IterableBase$(dart.dynamic);
+  let IterableBase = IterableBase$();
   let _iterator = Symbol('_iterator');
   let _NOT_MOVED_YET = Symbol('_NOT_MOVED_YET');
   let _state = Symbol('_state');
   let _move = Symbol('_move');
   let _HAS_NEXT_AND_NEXT_IN_CURRENT = Symbol('_HAS_NEXT_AND_NEXT_IN_CURRENT');
   let _NO_NEXT = Symbol('_NO_NEXT');
   let HasNextIterator$ = dart.generic(function(E) {
     class HasNextIterator extends core.Object {
       HasNextIterator(iterator$) {
         this[_iterator] = iterator$;
@@ skipping 18 matching lines @@
         } else {
           this[_state] = HasNextIterator[_NO_NEXT];
         }
       }
     }
     HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT = 0;
     HasNextIterator._NO_NEXT = 1;
     HasNextIterator._NOT_MOVED_YET = 2;
     return HasNextIterator;
   });
-  let HasNextIterator = HasNextIterator$(dart.dynamic);
+  let HasNextIterator = HasNextIterator$();
   let _literal = Symbol('_literal');
   let _empty = Symbol('_empty');
   let LinkedHashMap$ = dart.generic(function(K, V) {
     class LinkedHashMap extends core.Object {
       LinkedHashMap(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
@@ skipping 50 matching lines @@
     }
     LinkedHashMap[dart.implements] = () => [HashMap$(K, V)];
     dart.defineNamedConstructor(LinkedHashMap, 'identity');
     dart.defineNamedConstructor(LinkedHashMap, 'from');
     dart.defineNamedConstructor(LinkedHashMap, 'fromIterable');
     dart.defineNamedConstructor(LinkedHashMap, 'fromIterables');
     dart.defineNamedConstructor(LinkedHashMap, _literal);
     dart.defineNamedConstructor(LinkedHashMap, _empty);
     return LinkedHashMap;
   });
-  let LinkedHashMap = LinkedHashMap$(dart.dynamic, dart.dynamic);
+  let LinkedHashMap = LinkedHashMap$();
   let LinkedHashSet$ = dart.generic(function(E) {
     class LinkedHashSet extends core.Object {
       LinkedHashSet(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_LinkedHashSet$(E))();
@@ skipping 26 matching lines @@
           result.add(element);
         }
         return result;
       }
     }
     LinkedHashSet[dart.implements] = () => [HashSet$(E)];
     dart.defineNamedConstructor(LinkedHashSet, 'identity');
     dart.defineNamedConstructor(LinkedHashSet, 'from');
     return LinkedHashSet;
   });
-  let LinkedHashSet = LinkedHashSet$(dart.dynamic);
+  let LinkedHashSet = LinkedHashSet$();
   let _modificationCount = Symbol('_modificationCount');
   let _length = Symbol('_length');
   let _next = Symbol('_next');
   let _previous = Symbol('_previous');
   let _insertAfter = Symbol('_insertAfter');
   let _list = Symbol('_list');
   let _unlink = Symbol('_unlink');
   let LinkedList$ = dart.generic(function(E) {
     class LinkedList extends IterableBase$(E) {
       LinkedList() {
@@ skipping 89 matching lines @@
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         entry[_next][_previous] = entry[_previous];
         entry[_previous][_next] = entry[_next];
         this[_length] = dart.notNull(this[_length]) - 1;
         entry[_list] = entry[_next] = entry[_previous] = null;
       }
     }
     LinkedList[dart.implements] = () => [_LinkedListLink];
     return LinkedList;
   });
-  let LinkedList = LinkedList$(dart.dynamic);
+  let LinkedList = LinkedList$();
   let _current = Symbol('_current');
   let _LinkedListIterator$ = dart.generic(function(E) {
     class _LinkedListIterator extends core.Object {
       _LinkedListIterator(list) {
         this[_list] = list;
         this[_modificationCount] = list[_modificationCount];
         this[_next] = list[_next];
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (core.identical(this[_next], this[_list])) {
           this[_current] = null;
           return false;
         }
         if (this[_modificationCount] != this[_list][_modificationCount]) {
           throw new core.ConcurrentModificationError(this);
         }
         this[_current] = dart.as(this[_next], E);
         this[_next] = this[_next][_next];
         return true;
       }
     }
     _LinkedListIterator[dart.implements] = () => [core.Iterator$(E)];
     return _LinkedListIterator;
   });
-  let _LinkedListIterator = _LinkedListIterator$(dart.dynamic);
+  let _LinkedListIterator = _LinkedListIterator$();
   class _LinkedListLink extends core.Object {
     _LinkedListLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
   let LinkedListEntry$ = dart.generic(function(E) {
     class LinkedListEntry extends core.Object {
       LinkedListEntry() {
         this[_list] = null;
@@ skipping 20 matching lines @@
       insertAfter(entry) {
         this[_list]._insertAfter(this, entry);
       }
       insertBefore(entry) {
         this[_list]._insertAfter(this[_previous], entry);
       }
     }
     LinkedListEntry[dart.implements] = () => [_LinkedListLink];
     return LinkedListEntry;
   });
-  let LinkedListEntry = LinkedListEntry$(dart.dynamic);
+  let LinkedListEntry = LinkedListEntry$();
   let _filter = Symbol('_filter');
   let ListMixin$ = dart.generic(function(E) {
     class ListMixin extends core.Object {
       get iterator() {
         return new (_internal.ListIterator$(E))(this);
       }
       elementAt(index) {
         return this.get(index);
       }
       forEach(action) {
@@ skipping 431 matching lines @@
       get reversed() {
         return new (_internal.ReversedListIterable$(E))(this);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '[', ']');
       }
     }
     ListMixin[dart.implements] = () => [core.List$(E)];
     return ListMixin;
   });
-  let ListMixin = ListMixin$(dart.dynamic);
+  let ListMixin = ListMixin$();
   let ListBase$ = dart.generic(function(E) {
     class ListBase extends dart.mixin(core.Object, ListMixin$(E)) {
       static listToString(list) {
         return IterableBase.iterableToFullString(list, '[', ']');
       }
     }
     return ListBase;
   });
-  let ListBase = ListBase$(dart.dynamic);
+  let ListBase = ListBase$();
   let MapMixin$ = dart.generic(function(K, V) {
     class MapMixin extends core.Object {
       forEach(action) {
         for (let key of this.keys) {
           action(key, this.get(key));
         }
       }
       addAll(other) {
         for (let key of other.keys) {
           this.set(key, other.get(key));
@@ skipping 27 matching lines @@
       get values() {
         return new (_MapBaseValueIterable$(V))(this);
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     MapMixin[dart.implements] = () => [core.Map$(K, V)];
     return MapMixin;
   });
-  let MapMixin = MapMixin$(dart.dynamic, dart.dynamic);
+  let MapMixin = MapMixin$();
   let MapBase$ = dart.generic(function(K, V) {
-    class MapBase extends dart.mixin(MapMixin$(K, V)) {
-    }
+    class MapBase extends dart.mixin(MapMixin$(K, V)) {}
     return MapBase;
   });
-  let MapBase = MapBase$(dart.dynamic, dart.dynamic);
+  let MapBase = MapBase$();
   let _UnmodifiableMapMixin$ = dart.generic(function(K, V) {
     class _UnmodifiableMapMixin extends core.Object {
       set(key, value) {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       addAll(other) {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       clear() {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       remove(key) {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       putIfAbsent(key, ifAbsent) {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
     }
     _UnmodifiableMapMixin[dart.implements] = () => [core.Map$(K, V)];
     return _UnmodifiableMapMixin;
   });
-  let _UnmodifiableMapMixin = _UnmodifiableMapMixin$(dart.dynamic, dart.dynamic);
+  let _UnmodifiableMapMixin = _UnmodifiableMapMixin$();
   let UnmodifiableMapBase$ = dart.generic(function(K, V) {
-    class UnmodifiableMapBase extends dart.mixin(_UnmodifiableMapMixin$(K, V)) {
-    }
+    class UnmodifiableMapBase extends dart.mixin(_UnmodifiableMapMixin$(K, V)) {}
     return UnmodifiableMapBase;
   });
-  let UnmodifiableMapBase = UnmodifiableMapBase$(dart.dynamic, dart.dynamic);
+  let UnmodifiableMapBase = UnmodifiableMapBase$();
   let _map = Symbol('_map');
   let _MapBaseValueIterable$ = dart.generic(function(V) {
     class _MapBaseValueIterable extends IterableBase$(V) {
       _MapBaseValueIterable(map$) {
         this[_map] = map$;
         super.IterableBase();
       }
       get length() {
         return this[_map].length;
       }
@@ skipping 12 matching lines @@
       get last() {
         return dart.as(this[_map].get(this[_map].keys.last), V);
       }
       get iterator() {
         return new (_MapBaseValueIterator$(V))(this[_map]);
       }
     }
     _MapBaseValueIterable[dart.implements] = () => [_internal.EfficientLength];
     return _MapBaseValueIterable;
   });
-  let _MapBaseValueIterable = _MapBaseValueIterable$(dart.dynamic);
+  let _MapBaseValueIterable = _MapBaseValueIterable$();
   let _keys = Symbol('_keys');
   let _MapBaseValueIterator$ = dart.generic(function(V) {
     class _MapBaseValueIterator extends core.Object {
       _MapBaseValueIterator(map) {
         this[_map] = map;
         this[_keys] = map.keys.iterator;
         this[_current] = null;
       }
       moveNext() {
         if (this[_keys].moveNext()) {
           this[_current] = dart.as(this[_map].get(this[_keys].current), V);
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     _MapBaseValueIterator[dart.implements] = () => [core.Iterator$(V)];
     return _MapBaseValueIterator;
   });
-  let _MapBaseValueIterator = _MapBaseValueIterator$(dart.dynamic);
+  let _MapBaseValueIterator = _MapBaseValueIterator$();
   let MapView$ = dart.generic(function(K, V) {
     class MapView extends core.Object {
       MapView(map) {
         this[_map] = map;
       }
       get(key) {
         return this[_map].get(key);
       }
       set(key, value) {
         this[_map].set(key, value);
@@ skipping 34 matching lines @@
       toString() {
         return this[_map].toString();
       }
       get values() {
         return this[_map].values;
       }
     }
     MapView[dart.implements] = () => [core.Map$(K, V)];
     return MapView;
   });
-  let MapView = MapView$(dart.dynamic, dart.dynamic);
+  let MapView = MapView$();
   let UnmodifiableMapView$ = dart.generic(function(K, V) {
-    class UnmodifiableMapView extends dart.mixin(_UnmodifiableMapMixin$(K, V)) {
-    }
+    class UnmodifiableMapView extends dart.mixin(_UnmodifiableMapMixin$(K, V)) {}
     return UnmodifiableMapView;
   });
-  let UnmodifiableMapView = UnmodifiableMapView$(dart.dynamic, dart.dynamic);
+  let UnmodifiableMapView = UnmodifiableMapView$();
   let _id = Symbol('_id');
   let _fillMapWithMappedIterable = Symbol('_fillMapWithMappedIterable');
   let _fillMapWithIterables = Symbol('_fillMapWithIterables');
   class Maps extends core.Object {
     static containsValue(map, value) {
       for (let v of map.values) {
         if (dart.equals(value, v)) {
           return true;
         }
       }
@@ skipping 95 matching lines @@
         return new (ListQueue$(E))();
       }
       from(elements) {
         return new ListQueue$(E).from(elements);
       }
     }
     Queue[dart.implements] = () => [core.Iterable$(E), _internal.EfficientLength];
     dart.defineNamedConstructor(Queue, 'from');
     return Queue;
   });
-  let Queue = Queue$(dart.dynamic);
+  let Queue = Queue$();
   let _element = Symbol('_element');
   let _link = Symbol('_link');
   let _asNonSentinelEntry = Symbol('_asNonSentinelEntry');
   let DoubleLinkedQueueEntry$ = dart.generic(function(E) {
     class DoubleLinkedQueueEntry extends core.Object {
       DoubleLinkedQueueEntry(e) {
         this[_element] = e;
         this[_previous] = null;
         this[_next] = null;
       }
@@ skipping 27 matching lines @@
       }
       get element() {
         return this[_element];
       }
       set element(e) {
         this[_element] = e;
       }
     }
     return DoubleLinkedQueueEntry;
   });
-  let DoubleLinkedQueueEntry = DoubleLinkedQueueEntry$(dart.dynamic);
+  let DoubleLinkedQueueEntry = DoubleLinkedQueueEntry$();
   let _DoubleLinkedQueueEntrySentinel$ = dart.generic(function(E) {
     class _DoubleLinkedQueueEntrySentinel extends DoubleLinkedQueueEntry$(E) {
       _DoubleLinkedQueueEntrySentinel() {
         super.DoubleLinkedQueueEntry(null);
         this[_link](this, this);
       }
       remove() {
         throw _internal.IterableElementError.noElement();
       }
       [_asNonSentinelEntry]() {
         return null;
       }
       set element(e) {
         dart.assert(false);
       }
       get element() {
         throw _internal.IterableElementError.noElement();
       }
     }
     return _DoubleLinkedQueueEntrySentinel;
   });
-  let _DoubleLinkedQueueEntrySentinel = _DoubleLinkedQueueEntrySentinel$(dart.dynamic);
+  let _DoubleLinkedQueueEntrySentinel = _DoubleLinkedQueueEntrySentinel$();
   let _sentinel = Symbol('_sentinel');
   let _elementCount = Symbol('_elementCount');
   let DoubleLinkedQueue$ = dart.generic(function(E) {
     class DoubleLinkedQueue extends IterableBase$(E) {
       DoubleLinkedQueue() {
         this[_sentinel] = null;
         this[_elementCount] = 0;
         super.IterableBase();
         this[_sentinel] = new (_DoubleLinkedQueueEntrySentinel$(E))();
       }
@@ skipping 102 matching lines @@
         return new (_DoubleLinkedQueueIterator$(E))(this[_sentinel]);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     DoubleLinkedQueue[dart.implements] = () => [Queue$(E)];
     dart.defineNamedConstructor(DoubleLinkedQueue, 'from');
     return DoubleLinkedQueue;
   });
-  let DoubleLinkedQueue = DoubleLinkedQueue$(dart.dynamic);
+  let DoubleLinkedQueue = DoubleLinkedQueue$();
   let _nextEntry = Symbol('_nextEntry');
   let _DoubleLinkedQueueIterator$ = dart.generic(function(E) {
     class _DoubleLinkedQueueIterator extends core.Object {
       _DoubleLinkedQueueIterator(sentinel) {
         this[_sentinel] = sentinel;
         this[_nextEntry] = sentinel[_next];
         this[_current] = null;
       }
       moveNext() {
         if (!dart.notNull(core.identical(this[_nextEntry], this[_sentinel]))) {
           this[_current] = this[_nextEntry][_element];
           this[_nextEntry] = this[_nextEntry][_next];
           return true;
         }
         this[_current] = null;
         this[_nextEntry] = this[_sentinel] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     _DoubleLinkedQueueIterator[dart.implements] = () => [core.Iterator$(E)];
     return _DoubleLinkedQueueIterator;
   });
-  let _DoubleLinkedQueueIterator = _DoubleLinkedQueueIterator$(dart.dynamic);
+  let _DoubleLinkedQueueIterator = _DoubleLinkedQueueIterator$();
   let _head = Symbol('_head');
   let _tail = Symbol('_tail');
   let _table = Symbol('_table');
   let _INITIAL_CAPACITY = Symbol('_INITIAL_CAPACITY');
   let _isPowerOf2 = Symbol('_isPowerOf2');
   let _nextPowerOf2 = Symbol('_nextPowerOf2');
   let _checkModification = Symbol('_checkModification');
   let _writeToList = Symbol('_writeToList');
   let _add = Symbol('_add');
   let _preGrow = Symbol('_preGrow');
@@ skipping 274 matching lines @@
         this[_tail] = this[_writeToList](newTable);
         this[_table] = newTable;
         this[_head] = 0;
       }
     }
     ListQueue[dart.implements] = () => [Queue$(E)];
     dart.defineNamedConstructor(ListQueue, 'from');
     ListQueue._INITIAL_CAPACITY = 8;
     return ListQueue;
   });
-  let ListQueue = ListQueue$(dart.dynamic);
+  let ListQueue = ListQueue$();
   let _queue = Symbol('_queue');
   let _end = Symbol('_end');
   let _position = Symbol('_position');
   let _ListQueueIterator$ = dart.generic(function(E) {
     class _ListQueueIterator extends core.Object {
       _ListQueueIterator(queue) {
         this[_queue] = queue;
         this[_end] = queue[_tail];
         this[_modificationCount] = queue[_modificationCount];
         this[_position] = queue[_head];
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         this[_queue]._checkModification(this[_modificationCount]);
         if (this[_position] == this[_end]) {
           this[_current] = null;
           return false;
         }
         this[_current] = dart.as(this[_queue][_table].get(this[_position]), E);
         this[_position] = dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table].length) - 1;
         return true;
       }
     }
     _ListQueueIterator[dart.implements] = () => [core.Iterator$(E)];
     return _ListQueueIterator;
   });
-  let _ListQueueIterator = _ListQueueIterator$(dart.dynamic);
+  let _ListQueueIterator = _ListQueueIterator$();
+  let _Predicate$ = dart.generic(function(T) {
+    class _Predicate extends core.Function {}
+    return _Predicate;
+  });
+  let _Predicate = _Predicate$();
   let _SplayTreeNode$ = dart.generic(function(K) {
     class _SplayTreeNode extends core.Object {
       _SplayTreeNode(key) {
         this.key = key;
         this.left = null;
         this.right = null;
       }
     }
     return _SplayTreeNode;
   });
-  let _SplayTreeNode = _SplayTreeNode$(dart.dynamic);
+  let _SplayTreeNode = _SplayTreeNode$();
   let _SplayTreeMapNode$ = dart.generic(function(K, V) {
     class _SplayTreeMapNode extends _SplayTreeNode$(K) {
       _SplayTreeMapNode(key, value) {
         this.value = value;
         super._SplayTreeNode(key);
       }
     }
     return _SplayTreeMapNode;
   });
-  let _SplayTreeMapNode = _SplayTreeMapNode$(dart.dynamic, dart.dynamic);
+  let _SplayTreeMapNode = _SplayTreeMapNode$();
   let _dummy = Symbol('_dummy');
   let _root = Symbol('_root');
   let _count = Symbol('_count');
   let _splayCount = Symbol('_splayCount');
   let _splay = Symbol('_splay');
   let _compare = Symbol('_compare');
   let _splayMin = Symbol('_splayMin');
   let _splayMax = Symbol('_splayMax');
   let _addNewRoot = Symbol('_addNewRoot');
   let _first = Symbol('_first');
@@ skipping 130 matching lines @@
         return this[_root];
       }
       [_clear]() {
         this[_root] = null;
         this[_count] = 0;
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
       }
     }
     return _SplayTree;
   });
-  let _SplayTree = _SplayTree$(dart.dynamic);
+  let _SplayTree = _SplayTree$();
   let _TypeTest$ = dart.generic(function(T) {
     class _TypeTest extends core.Object {
       test(v) {
         return dart.is(v, T);
       }
     }
     return _TypeTest;
   });
-  let _TypeTest = _TypeTest$(dart.dynamic);
+  let _TypeTest = _TypeTest$();
   let _comparator = Symbol('_comparator');
   let _validKey = Symbol('_validKey');
   let _internal$ = Symbol('_internal');
   let SplayTreeMap$ = dart.generic(function(K, V) {
     class SplayTreeMap extends _SplayTree$(K) {
       SplayTreeMap(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
@@ skipping 190 matching lines @@
         return node.key;
       }
     }
     SplayTreeMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(SplayTreeMap, 'from');
     dart.defineNamedConstructor(SplayTreeMap, 'fromIterable');
     dart.defineNamedConstructor(SplayTreeMap, 'fromIterables');
     dart.defineNamedConstructor(SplayTreeMap, _internal$);
     return SplayTreeMap;
   });
-  let SplayTreeMap = SplayTreeMap$(dart.dynamic, dart.dynamic);
+  let SplayTreeMap = SplayTreeMap$();
   let _workList = Symbol('_workList');
   let _tree = Symbol('_tree');
   let _currentNode = Symbol('_currentNode');
   let _findLeftMostDescendent = Symbol('_findLeftMostDescendent');
   let _getValue = Symbol('_getValue');
   let _rebuildWorkList = Symbol('_rebuildWorkList');
   let _SplayTreeIterator$ = dart.generic(function(T) {
     class _SplayTreeIterator extends core.Object {
       _SplayTreeIterator(tree) {
         this[_workList] = new core.List$(_SplayTreeNode).from([]);
@@ skipping 54 matching lines @@
         }
         this[_currentNode] = this[_workList].removeLast();
         this[_findLeftMostDescendent](this[_currentNode].right);
         return true;
       }
     }
     _SplayTreeIterator[dart.implements] = () => [core.Iterator$(T)];
     dart.defineNamedConstructor(_SplayTreeIterator, 'startAt');
     return _SplayTreeIterator;
   });
-  let _SplayTreeIterator = _SplayTreeIterator$(dart.dynamic);
+  let _SplayTreeIterator = _SplayTreeIterator$();
   let _SplayTreeKeyIterable$ = dart.generic(function(K) {
     class _SplayTreeKeyIterable extends IterableBase$(K) {
       _SplayTreeKeyIterable(tree$) {
         this[_tree] = tree$;
         super.IterableBase();
       }
       get length() {
         return this[_tree][_count];
       }
       get isEmpty() {
         return this[_tree][_count] == 0;
       }
       get iterator() {
         return new (_SplayTreeKeyIterator$(K))(this[_tree]);
       }
       toSet() {
         let setOrMap = this[_tree];
         let set = new (SplayTreeSet$(K))(dart.as(setOrMap[_comparator], dart.throw_("Unimplemented type (K, K) → int")), dart.as(setOrMap[_validKey], dart.throw_("Unimplemented type (dynamic) → bool")));
         set[_count] = this[_tree][_count];
         set[_root] = set._copyNode(this[_tree][_root]);
         return set;
       }
     }
     _SplayTreeKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     return _SplayTreeKeyIterable;
   });
-  let _SplayTreeKeyIterable = _SplayTreeKeyIterable$(dart.dynamic);
+  let _SplayTreeKeyIterable = _SplayTreeKeyIterable$();
   let _SplayTreeValueIterable$ = dart.generic(function(K, V) {
     class _SplayTreeValueIterable extends IterableBase$(V) {
       _SplayTreeValueIterable(map$) {
         this[_map] = map$;
         super.IterableBase();
       }
       get length() {
         return this[_map][_count];
       }
       get isEmpty() {
         return this[_map][_count] == 0;
       }
       get iterator() {
         return new (_SplayTreeValueIterator$(K, V))(this[_map]);
       }
     }
     _SplayTreeValueIterable[dart.implements] = () => [_internal.EfficientLength];
     return _SplayTreeValueIterable;
   });
-  let _SplayTreeValueIterable = _SplayTreeValueIterable$(dart.dynamic, dart.dynamic);
+  let _SplayTreeValueIterable = _SplayTreeValueIterable$();
   let _SplayTreeKeyIterator$ = dart.generic(function(K) {
     class _SplayTreeKeyIterator extends _SplayTreeIterator$(K) {
       _SplayTreeKeyIterator(map) {
         super._SplayTreeIterator(map);
       }
       [_getValue](node) {
         return dart.as(node.key, K);
       }
     }
     return _SplayTreeKeyIterator;
   });
-  let _SplayTreeKeyIterator = _SplayTreeKeyIterator$(dart.dynamic);
+  let _SplayTreeKeyIterator = _SplayTreeKeyIterator$();
   let _SplayTreeValueIterator$ = dart.generic(function(K, V) {
     class _SplayTreeValueIterator extends _SplayTreeIterator$(V) {
       _SplayTreeValueIterator(map) {
         super._SplayTreeIterator(map);
       }
       [_getValue](node) {
         return dart.as(node.value, V);
       }
     }
     return _SplayTreeValueIterator;
   });
-  let _SplayTreeValueIterator = _SplayTreeValueIterator$(dart.dynamic, dart.dynamic);
+  let _SplayTreeValueIterator = _SplayTreeValueIterator$();
   let _SplayTreeNodeIterator$ = dart.generic(function(K) {
     class _SplayTreeNodeIterator extends _SplayTreeIterator$(_SplayTreeNode$(K)) {
       _SplayTreeNodeIterator(tree) {
         super._SplayTreeIterator(tree);
       }
       startAt(tree, startKey) {
         super.startAt(tree, startKey);
       }
       [_getValue](node) {
         return dart.as(node, _SplayTreeNode$(K));
       }
     }
     dart.defineNamedConstructor(_SplayTreeNodeIterator, 'startAt');
     return _SplayTreeNodeIterator;
   });
-  let _SplayTreeNodeIterator = _SplayTreeNodeIterator$(dart.dynamic);
+  let _SplayTreeNodeIterator = _SplayTreeNodeIterator$();
   let _clone = Symbol('_clone');
   let _copyNode = Symbol('_copyNode');
   let SplayTreeSet$ = dart.generic(function(E) {
     class SplayTreeSet extends dart.mixin(_SplayTree$(E), IterableMixin$(E), SetMixin$(E)) {
       SplayTreeSet(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator);
@@ skipping 139 matching lines @@
       toSet() {
         return this[_clone]();
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     dart.defineNamedConstructor(SplayTreeSet, 'from');
     return SplayTreeSet;
   });
-  let SplayTreeSet = SplayTreeSet$(dart.dynamic);
+  let SplayTreeSet = SplayTreeSet$();
   let _strings = Symbol('_strings');
   let _nums = Symbol('_nums');
   let _rest = Symbol('_rest');
   let _isStringKey = Symbol('_isStringKey');
   let _hasTableEntry = Symbol('_hasTableEntry');
   let _isNumericKey = Symbol('_isNumericKey');
   let _containsKey = Symbol('_containsKey');
   let _getBucket = Symbol('_getBucket');
   let _findBucketIndex = Symbol('_findBucketIndex');
   let _computeKeys = Symbol('_computeKeys');
@@ skipping 261 matching lines @@
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _HashMap[_setTableEntry](table, temporaryKey, table);
         _HashMap[_deleteTableEntry](table, temporaryKey);
         return table;
       }
     }
     _HashMap[dart.implements] = () => [HashMap$(K, V)];
     return _HashMap;
   });
-  let _HashMap = _HashMap$(dart.dynamic, dart.dynamic);
+  let _HashMap = _HashMap$();
   let _IdentityHashMap$ = dart.generic(function(K, V) {
     class _IdentityHashMap extends _HashMap$(K, V) {
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = 2) {
           if (core.identical(bucket[i], key))
             return i;
         }
         return -1;
       }
     }
     return _IdentityHashMap;
   });
-  let _IdentityHashMap = _IdentityHashMap$(dart.dynamic, dart.dynamic);
+  let _IdentityHashMap = _IdentityHashMap$();
   let _equals = Symbol('_equals');
   let _hashCode = Symbol('_hashCode');
   let _CustomHashMap$ = dart.generic(function(K, V) {
     class _CustomHashMap extends _HashMap$(K, V) {
       _CustomHashMap(equals$, hashCode$, validKey) {
         this[_equals] = equals$;
         this[_hashCode] = hashCode$;
         this[_validKey] = dart.as(validKey != null ? validKey : (v) => dart.is(v, K), _Predicate);
         super._HashMap();
       }
@@ skipping 27 matching lines @@
             return i;
         }
         return -1;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     return _CustomHashMap;
   });
-  let _CustomHashMap = _CustomHashMap$(dart.dynamic, dart.dynamic);
+  let _CustomHashMap = _CustomHashMap$();
   let HashMapKeyIterable$ = dart.generic(function(E) {
     class HashMapKeyIterable extends IterableBase$(E) {
       HashMapKeyIterable(map$) {
         this[_map] = map$;
         super.IterableBase();
       }
       get length() {
         return dart.as(dart.dload(this[_map], '_length'), core.int);
       }
       get isEmpty() {
@@ skipping 11 matching lines @@
           f(dart.as(keys[i], E));
           if (keys !== dart.dload(this[_map], '_keys')) {
             throw new core.ConcurrentModificationError(this[_map]);
           }
         }
       }
     }
     HashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     return HashMapKeyIterable;
   });
-  let HashMapKeyIterable = HashMapKeyIterable$(dart.dynamic);
+  let HashMapKeyIterable = HashMapKeyIterable$();
   let _offset = Symbol('_offset');
   let HashMapKeyIterator$ = dart.generic(function(E) {
     class HashMapKeyIterator extends core.Object {
       HashMapKeyIterator(map$, keys$) {
         this[_map] = map$;
         this[_keys] = keys$;
         this[_offset] = 0;
         this[_current] = null;
       }
       get current() {
@@ skipping 10 matching lines @@
         } else {
           this[_current] = dart.as(keys[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
     HashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
     return HashMapKeyIterator;
   });
-  let HashMapKeyIterator = HashMapKeyIterator$(dart.dynamic);
+  let HashMapKeyIterator = HashMapKeyIterator$();
   let _modifications = Symbol('_modifications');
   let _value = Symbol('_value');
   let _newLinkedCell = Symbol('_newLinkedCell');
   let _unlinkCell = Symbol('_unlinkCell');
   let _modified = Symbol('_modified');
   let _key = Symbol('_key');
   let _LinkedHashMap$ = dart.generic(function(K, V) {
     class _LinkedHashMap extends core.Object {
       _LinkedHashMap() {
         this[_length] = 0;
@@ skipping 253 matching lines @@
         _LinkedHashMap[_deleteTableEntry](table, temporaryKey);
         return table;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     _LinkedHashMap[dart.implements] = () => [LinkedHashMap$(K, V), _js_helper.InternalMap];
     return _LinkedHashMap;
   });
-  let _LinkedHashMap = _LinkedHashMap$(dart.dynamic, dart.dynamic);
+  let _LinkedHashMap = _LinkedHashMap$();
   let _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
     class _LinkedIdentityHashMap extends _LinkedHashMap$(K, V) {
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (core.identical(cell[_key], key))
             return i;
         }
         return -1;
       }
     }
     return _LinkedIdentityHashMap;
   });
-  let _LinkedIdentityHashMap = _LinkedIdentityHashMap$(dart.dynamic, dart.dynamic);
+  let _LinkedIdentityHashMap = _LinkedIdentityHashMap$();
   let _LinkedCustomHashMap$ = dart.generic(function(K, V) {
     class _LinkedCustomHashMap extends _LinkedHashMap$(K, V) {
       _LinkedCustomHashMap(equals$, hashCode$, validKey) {
         this[_equals] = equals$;
         this[_hashCode] = hashCode$;
         this[_validKey] = dart.as(validKey != null ? validKey : (v) => dart.is(v, K), _Predicate);
         super._LinkedHashMap();
       }
       get(key) {
         if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
@@ skipping 23 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (this[_equals](dart.as(cell[_key], K), dart.as(key, K)))
             return i;
         }
         return -1;
       }
     }
     return _LinkedCustomHashMap;
   });
-  let _LinkedCustomHashMap = _LinkedCustomHashMap$(dart.dynamic, dart.dynamic);
+  let _LinkedCustomHashMap = _LinkedCustomHashMap$();
   class LinkedHashMapCell extends core.Object {
     LinkedHashMapCell(key$, value$) {
       this[_key] = key$;
       this[_value] = value$;
       this[_next] = null;
       this[_previous] = null;
     }
   }
   let LinkedHashMapKeyIterable$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterable extends IterableBase$(E) {
@@ skipping 21 matching lines @@
           if (!dart.equals(modifications, dart.dload(this[_map], '_modifications'))) {
             throw new core.ConcurrentModificationError(this[_map]);
           }
           cell = cell[_next];
         }
       }
     }
     LinkedHashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     return LinkedHashMapKeyIterable;
   });
-  let LinkedHashMapKeyIterable = LinkedHashMapKeyIterable$(dart.dynamic);
+  let LinkedHashMapKeyIterable = LinkedHashMapKeyIterable$();
   let _cell = Symbol('_cell');
   let LinkedHashMapKeyIterator$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterator extends core.Object {
       LinkedHashMapKeyIterator(map$, modifications$) {
         this[_map] = map$;
         this[_modifications] = modifications$;
         this[_cell] = null;
         this[_current] = null;
         this[_cell] = dart.as(dart.dload(this[_map], '_first'), LinkedHashMapCell);
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (!dart.equals(this[_modifications], dart.dload(this[_map], '_modifications'))) {
           throw new core.ConcurrentModificationError(this[_map]);
         } else if (this[_cell] == null) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(this[_cell][_key], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
     }
     LinkedHashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
     return LinkedHashMapKeyIterator;
   });
-  let LinkedHashMapKeyIterator = LinkedHashMapKeyIterator$(dart.dynamic);
+  let LinkedHashMapKeyIterator = LinkedHashMapKeyIterator$();
   let _elements = Symbol('_elements');
   let _computeElements = Symbol('_computeElements');
   let _isStringElement = Symbol('_isStringElement');
   let _isNumericElement = Symbol('_isNumericElement');
   let _contains = Symbol('_contains');
   let _lookup = Symbol('_lookup');
   let _HashSet$ = dart.generic(function(E) {
     class _HashSet extends _HashSetBase$(E) {
       _HashSet() {
         this[_length] = 0;
@@ skipping 216 matching lines @@
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _HashSet[_setTableEntry](table, temporaryKey, table);
         _HashSet[_deleteTableEntry](table, temporaryKey);
         return table;
       }
     }
     _HashSet[dart.implements] = () => [HashSet$(E)];
     return _HashSet;
   });
-  let _HashSet = _HashSet$(dart.dynamic);
+  let _HashSet = _HashSet$();
   let _IdentityHashSet$ = dart.generic(function(E) {
     class _IdentityHashSet extends _HashSet$(E) {
       [_newSet]() {
         return new (_IdentityHashSet$(E))();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (core.identical(bucket[i], element))
             return i;
         }
         return -1;
       }
     }
     return _IdentityHashSet;
   });
-  let _IdentityHashSet = _IdentityHashSet$(dart.dynamic);
+  let _IdentityHashSet = _IdentityHashSet$();
   let _equality = Symbol('_equality');
   let _hasher = Symbol('_hasher');
   let _CustomHashSet$ = dart.generic(function(E) {
     class _CustomHashSet extends _HashSet$(E) {
       _CustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
         this[_validKey] = dart.as(validKey != null ? validKey : (x) => dart.is(x, E), _Predicate);
         super._HashSet();
       }
@@ skipping 27 matching lines @@
         return super._lookup(object);
       }
       remove(object) {
         if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return false;
         return super._remove(object);
       }
     }
     return _CustomHashSet;
   });
-  let _CustomHashSet = _CustomHashSet$(dart.dynamic);
+  let _CustomHashSet = _CustomHashSet$();
   let HashSetIterator$ = dart.generic(function(E) {
     class HashSetIterator extends core.Object {
       HashSetIterator(set$, elements$) {
         this[_set] = set$;
         this[_elements] = elements$;
         this[_offset] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         let elements = this[_elements];
         let offset = this[_offset];
         if (elements !== dart.dload(this[_set], '_elements')) {
           throw new core.ConcurrentModificationError(this[_set]);
         } else if (dart.notNull(offset) >= elements.length) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(elements[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
     HashSetIterator[dart.implements] = () => [core.Iterator$(E)];
     return HashSetIterator;
   });
-  let HashSetIterator = HashSetIterator$(dart.dynamic);
+  let HashSetIterator = HashSetIterator$();
   let _unsupported = Symbol('_unsupported');
   let _LinkedHashSet$ = dart.generic(function(E) {
     class _LinkedHashSet extends _HashSetBase$(E) {
       _LinkedHashSet() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
         this[_rest] = null;
         this[_first] = null;
         this[_last] = null;
@@ skipping 251 matching lines @@
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _LinkedHashSet[_setTableEntry](table, temporaryKey, table);
         _LinkedHashSet[_deleteTableEntry](table, temporaryKey);
         return table;
       }
     }
     _LinkedHashSet[dart.implements] = () => [LinkedHashSet$(E)];
     return _LinkedHashSet;
   });
-  let _LinkedHashSet = _LinkedHashSet$(dart.dynamic);
+  let _LinkedHashSet = _LinkedHashSet$();
   let _LinkedIdentityHashSet$ = dart.generic(function(E) {
     class _LinkedIdentityHashSet extends _LinkedHashSet$(E) {
       [_newSet]() {
         return new (_LinkedIdentityHashSet$(E))();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (core.identical(cell[_element], element))
             return i;
         }
         return -1;
       }
     }
     return _LinkedIdentityHashSet;
   });
-  let _LinkedIdentityHashSet = _LinkedIdentityHashSet$(dart.dynamic);
+  let _LinkedIdentityHashSet = _LinkedIdentityHashSet$();
   let _LinkedCustomHashSet$ = dart.generic(function(E) {
     class _LinkedCustomHashSet extends _LinkedHashSet$(E) {
       _LinkedCustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
         this[_validKey] = dart.as(validKey != null ? validKey : (x) => dart.is(x, E), _Predicate);
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedCustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
@@ skipping 40 matching lines @@
       removeAll(elements) {
         for (let element of elements) {
           if (dart.dinvokef(this[_validKey], element)) {
             super._remove(element);
           }
         }
       }
     }
     return _LinkedCustomHashSet;
   });
-  let _LinkedCustomHashSet = _LinkedCustomHashSet$(dart.dynamic);
+  let _LinkedCustomHashSet = _LinkedCustomHashSet$();
   class LinkedHashSetCell extends core.Object {
     LinkedHashSetCell(element$) {
       this[_element] = element$;
       this[_next] = null;
       this[_previous] = null;
     }
   }
   let LinkedHashSetIterator$ = dart.generic(function(E) {
     class LinkedHashSetIterator extends core.Object {
       LinkedHashSetIterator(set$, modifications$) {
@@ skipping 15 matching lines @@
         } else {
           this[_current] = dart.as(this[_cell][_element], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
     }
     LinkedHashSetIterator[dart.implements] = () => [core.Iterator$(E)];
     return LinkedHashSetIterator;
   });
-  let LinkedHashSetIterator = LinkedHashSetIterator$(dart.dynamic);
+  let LinkedHashSetIterator = LinkedHashSetIterator$();
   // Exports:
+  exports.UnmodifiableListView$ = UnmodifiableListView$;
+  exports.HashMap$ = HashMap$;
   exports.HashMap = HashMap;
-  exports.HashMap$ = HashMap$;
+  exports.SetBase$ = SetBase$;
   exports.SetBase = SetBase;
-  exports.SetBase$ = SetBase$;
+  exports.SetMixin$ = SetMixin$;
   exports.SetMixin = SetMixin;
-  exports.SetMixin$ = SetMixin$;
+  exports.HashSet$ = HashSet$;
   exports.HashSet = HashSet;
-  exports.HashSet$ = HashSet$;
+  exports.IterableMixin$ = IterableMixin$;
   exports.IterableMixin = IterableMixin;
-  exports.IterableMixin$ = IterableMixin$;
+  exports.IterableBase$ = IterableBase$;
   exports.IterableBase = IterableBase;
-  exports.IterableBase$ = IterableBase$;
+  exports.HasNextIterator$ = HasNextIterator$;
   exports.HasNextIterator = HasNextIterator;
-  exports.HasNextIterator$ = HasNextIterator$;
+  exports.LinkedHashMap$ = LinkedHashMap$;
   exports.LinkedHashMap = LinkedHashMap;
-  exports.LinkedHashMap$ = LinkedHashMap$;
+  exports.LinkedHashSet$ = LinkedHashSet$;
   exports.LinkedHashSet = LinkedHashSet;
-  exports.LinkedHashSet$ = LinkedHashSet$;
+  exports.LinkedList$ = LinkedList$;
   exports.LinkedList = LinkedList;
-  exports.LinkedList$ = LinkedList$;
+  exports.LinkedListEntry$ = LinkedListEntry$;
   exports.LinkedListEntry = LinkedListEntry;
-  exports.LinkedListEntry$ = LinkedListEntry$;
+  exports.ListBase$ = ListBase$;
   exports.ListBase = ListBase;
-  exports.ListBase$ = ListBase$;
+  exports.ListMixin$ = ListMixin$;
   exports.ListMixin = ListMixin;
-  exports.ListMixin$ = ListMixin$;
+  exports.MapBase$ = MapBase$;
   exports.MapBase = MapBase;
-  exports.MapBase$ = MapBase$;
+  exports.MapMixin$ = MapMixin$;
   exports.MapMixin = MapMixin;
-  exports.MapMixin$ = MapMixin$;
+  exports.UnmodifiableMapBase$ = UnmodifiableMapBase$;
   exports.UnmodifiableMapBase = UnmodifiableMapBase;
-  exports.UnmodifiableMapBase$ = UnmodifiableMapBase$;
+  exports.MapView$ = MapView$;
   exports.MapView = MapView;
-  exports.MapView$ = MapView$;
+  exports.UnmodifiableMapView$ = UnmodifiableMapView$;
   exports.UnmodifiableMapView = UnmodifiableMapView;
-  exports.UnmodifiableMapView$ = UnmodifiableMapView$;
   exports.Maps = Maps;
+  exports.Queue$ = Queue$;
   exports.Queue = Queue;
-  exports.Queue$ = Queue$;
+  exports.DoubleLinkedQueueEntry$ = DoubleLinkedQueueEntry$;
   exports.DoubleLinkedQueueEntry = DoubleLinkedQueueEntry;
-  exports.DoubleLinkedQueueEntry$ = DoubleLinkedQueueEntry$;
+  exports.DoubleLinkedQueue$ = DoubleLinkedQueue$;
   exports.DoubleLinkedQueue = DoubleLinkedQueue;
-  exports.DoubleLinkedQueue$ = DoubleLinkedQueue$;
+  exports.ListQueue$ = ListQueue$;
   exports.ListQueue = ListQueue;
-  exports.ListQueue$ = ListQueue$;
+  exports.SplayTreeMap$ = SplayTreeMap$;
   exports.SplayTreeMap = SplayTreeMap;
-  exports.SplayTreeMap$ = SplayTreeMap$;
+  exports.SplayTreeSet$ = SplayTreeSet$;
   exports.SplayTreeSet = SplayTreeSet;
-  exports.SplayTreeSet$ = SplayTreeSet$;
+  exports.HashMapKeyIterable$ = HashMapKeyIterable$;
   exports.HashMapKeyIterable = HashMapKeyIterable;
-  exports.HashMapKeyIterable$ = HashMapKeyIterable$;
+  exports.HashMapKeyIterator$ = HashMapKeyIterator$;
   exports.HashMapKeyIterator = HashMapKeyIterator;
-  exports.HashMapKeyIterator$ = HashMapKeyIterator$;
   exports.LinkedHashMapCell = LinkedHashMapCell;
+  exports.LinkedHashMapKeyIterable$ = LinkedHashMapKeyIterable$;
   exports.LinkedHashMapKeyIterable = LinkedHashMapKeyIterable;
-  exports.LinkedHashMapKeyIterable$ = LinkedHashMapKeyIterable$;
+  exports.LinkedHashMapKeyIterator$ = LinkedHashMapKeyIterator$;
   exports.LinkedHashMapKeyIterator = LinkedHashMapKeyIterator;
-  exports.LinkedHashMapKeyIterator$ = LinkedHashMapKeyIterator$;
+  exports.HashSetIterator$ = HashSetIterator$;
   exports.HashSetIterator = HashSetIterator;
-  exports.HashSetIterator$ = HashSetIterator$;
   exports.LinkedHashSetCell = LinkedHashSetCell;
+  exports.LinkedHashSetIterator$ = LinkedHashSetIterator$;
   exports.LinkedHashSetIterator = LinkedHashSetIterator;
-  exports.LinkedHashSetIterator$ = LinkedHashSetIterator$;
 })(collection || (collection = {}));