anchor.diff:   * The entry contains a reference to the queue, allowing
    * [append]/[prepend] to update the list length.
    */
  -class _DoubleLinkedQueueElement<E> extends _DoubleLinkedQueueEntry<E>
  -                                   implements DoubleLinkedQueueEntry<E> {
  -  E element;
  -  _DoubleLinkedQueueElement(this.element, DoubleLinkedQueue<E> queue)
  -      : super(queue);
  +class _DoubleLinkedQueueElement<E> extends _DoubleLinkedQueueEntry<E> {
  +  _DoubleLinkedQueueElement(E element, DoubleLinkedQueue<E> queue)
  +      : super(element, queue);
   
     void append(E e) {
       _append(e);
  
positive.code:  * An entry in a doubly linked list. It contains a pointer to the next
   * entry, the previous entry, and the boxed element.
   */
  abstract class DoubleLinkedQueueEntry<E> {
    factory DoubleLinkedQueueEntry(E element) = _UserDoubleLinkedQueueEntry<E>;
  
    /// The element in the queue.
    E get element;
  
    /// Appends the given [e] as entry just after this entry.
    void append(E e);
  
    /// Prepends the given [e] as entry just before this entry.
    void prepend(E e);
  
    /// Returns the previous entry or `null` if there is none.
    DoubleLinkedQueueEntry<E> previousEntry();
  
    /// Returns the next entry or `null` if there is none.
    DoubleLinkedQueueEntry<E> nextEntry();
  }
  
  /// Default implementation of a doubly linked queue entry.
  ///
  /// This implementation is only used if a user instantiates a
  /// [DoubleLinkedQueueEntry] directly. The internal implementations don't use
  /// this class.
  class _UserDoubleLinkedQueueEntry<E>
      extends _DoubleLink<_UserDoubleLinkedQueueEntry<E>>
      implements DoubleLinkedQueueEntry<E> {
    E element;
  
    _UserDoubleLinkedQueueEntry(this.element);
  
    void append(E e) {
      new _UserDoubleLinkedQueueEntry<E>(e)._link(this, _nextLink);
    }
  
    void prepend(E e) {
      new _UserDoubleLinkedQueueEntry<E>(e)._link(_previousLink, this);
    }
  
    E remove() {
  
negative.code: }
  
  
  class _DoubleLink<Link extends _DoubleLink> {
    Link _previousLink;
    Link _nextLink;
  
    void _link(Link previous, Link next) {
      _nextLink = next;
      _previousLink = previous;
      if (previous != null) previous._nextLink = this;
  