anchor.diff:    }
   
     /** Hit by, e.g., [DoubleLinkedQueue.first] if the queue is empty. */
  -  E get element {
  +  E get _element {
       throw IterableElementError.noElement();
     }
   }
  
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: 
    E get first {
      _DoubleLinkedQueueEntry<E> firstEntry = _sentinel._nextLink;
      return firstEntry._element;
    }
  
    E get last {
      _DoubleLinkedQueueEntry<E> lastEntry = _sentinel._previousLink;
      return lastEntry._element;
    }
  
    E get single {
  