anchor.diff:  
       bool stop = false;
   
  +    // Algorithm that works on simple cases with basic list
  +    // transformations.
  +    //
  +    // It tries to reduce the diff problem by simultaneously iterating
  +    // from the beginning and the end of both lists, if keys are the
  +    // same, they're updated, if node is moved from the beginning to the
  +    // end of the current cursor positions or vice versa it just
  +    // performs move operation and continues to reduce the diff problem.
       outer: do {
         stop = true;
   
  -      // prefix
  +      // Update nodes with the same key at the beginning.
         while (aStartNode.key == bStartNode.key) {
           aStartNode.update(bStartNode, context);
   
  
positive.code:     int aEnd = a.length - 1;
      int bEnd = b.length - 1;
  
      // prefix
      while (aStart <= aEnd && bStart <= bEnd) {
        final aNode = a[aStart];
        final bNode = b[bStart];
  
negative.code:       aNode.update(bNode, context);
      }
  
      // Iterate through the remaining nodes and if they have the same
      // type, then update, otherwise just remove the old node and insert
      // the new one.
      while (aStart <= aEnd && bStart <= bEnd) {
        final aNode = a[aStart++];
        final bNode = b[bStart++];
        if (aNode.sameType(bNode)) {
          aNode.update(bNode, context);
        } else {
          insertBefore(bNode, aNode.ref, context);
          removeChild(aNode, context);
        }
      }
  
      // All nodes from [a] are updated, insert the rest from [b].
      while (aStart <= aEnd) {
        removeChild(a[aStart++], context);
      }
  
      final nextPos = bEnd + 1;
      final next = nextPos < b.length ? b[nextPos].ref : null;
  
      // All nodes from [b] are updated, remove the rest from [a].
      while (bStart <= bEnd) {
        insertBefore(b[bStart++], next, context);
      }
    }
  
  