anchor.diff:    }
   
     /**
  -   * Add [entry] to the beginning of the list.
  +   * Add [entry] to the beginning of the linked list.
      */
     void addFirst(E entry) {
       _insertAfter(this, entry);
     }
   
     /**
  -   * Add [entry] to the end of the list.
  +   * Add [entry] to the end of the linked list.
      */
     void add(E entry) {
       _insertAfter(_previous, entry);
     }
   
     /**
  -   * Add [entries] to the end of the list.
  +   * Add [entries] to the end of the linked list.
      */
     void addAll(Iterable<E> entries) {
       entries.forEach((entry) => _insertAfter(_previous, entry));
     }
   
     /**
  -   * Remove [entry] from the list. This is the same as calling `entry.unlink()`.
  -   *
  -   * If [entry] is not in the list, `false` is returned.
  +   * Remove [entry] from the linked list.
  +   *
  +   * Returns false and does nothing if [entry] is not in this linked list.
  +   *
  +   * This is equivalent to calling `entry.unlink()` if the entry is in this
  +   * list.
      */
     bool remove(E entry) {
       if (entry._list != this) return false;
  
positive.code: 
  
  /**
   * Entry element for a [LinkedList]. Any entry must extend this class.
   */
  abstract class LinkedListEntry<E extends LinkedListEntry<E>>
      implements _LinkedListLink {
  
negative.code: 
  
  /**
   * A specialized double-linked list of elements that extends [LinkedListEntry].
   *
   * This is not a generic data structure. It only accepts elements that extend
   * the [LinkedListEntry] class. See the [Queue] implementations for
   * generic collections that allow constant time adding and removing at the ends.
   *
   * This is not a [List] implementation. Despite its name, this class does not
   * implement the [List] interface. It does not allow constant time lookup by
   * index.
   *
   * Because the elements themselves contain the links of this linked list,
   * each element can be in only one list at a time. To add an element to another
   * list, it must first be removed from its current list (if any).
   *
   * In return, each element knows its own place in the linked list, as well as
   * which list it is in. This allows constant time [LinkedListEntry.addAfter],
   * [LinkedListEntry.addBefore] and [LinkedListEntry.unlink] operations
   * when all you have is the element.
   *
   * A `LinkedList` also allows constant time adding and removing at either end,
   * and a constant time length getter.
   */
  class LinkedList<E extends LinkedListEntry<E>>
      extends IterableBase<E>
  