anchor.diff:          bEndNode = b[bEnd];
   
           stop = false;
  -      }
  -
  +        continue outer;
  +      }
  +
  +      // Move nodes from right to left.
         while (aEndNode.key == bStartNode.key) {
           aEndNode.update(bStartNode, context);
   
  
positive.code:       }
  
        if (moved) {
          // if it is detected that one of the nodes is in the wrong place
          // we will find minimum number of moves using slightly modified
          // LIS algorithm.
          //
          // moves and inserts are apllied in one step, when `sources[i]` is
          // equal to -1, it means that node with the same key doesn't exist
          // in list `a`, so we should make insert operation.
          //
          // all modifications are performed from right to left, so we
          // can use insertBefore method and use reference to the html element
          // from the next virtual node.
          final seq = _lis(sources);
          var j = seq.length - 1;
  
          for (var i = bLength - 1; i >= 0; i--) {
            if (sources[i] == -1) {
              final pos = i + bStart;
  
negative.code:     } while (!stop && aStart <= aEnd && bStart <= bEnd);
  
      if (aStart > aEnd) {
        // All nodes from [a] are updated, insert the rest from [b].
        final nextPos = bEnd + 1;
        final next = nextPos < b.length ? b[nextPos].ref : null;
        while (bStart <= bEnd) {
          insertBefore(b[bStart++], next, context);
        }
      } else if (bStart > bEnd) {
        // All nodes from [b] are updated, remove the rest from [a].
        while (aStart <= aEnd) {
          removeChild(a[aStart++], context);
        }
      } else {
        // Perform more complex update algorithm on the remaining nodes.
        //
        // We start by marking all nodes from [b] as inserted, then we try
        // to find all removed nodes and simultaneously perform updates on
        // the nodes that exists in both lists and replacing "inserted"
        // marks with the position of the node from the list [b] in list [a].
        // Then we just need to perform slightly modified LIS algorith,
        // that ignores "inserted" marks and find common subsequence and
        // move all nodes that doesn't belong to this subsequence, or
        // insert if they have "inserted" mark.
        final aLength = aEnd - aStart + 1;
        final bLength = bEnd - bStart + 1;
  
        // -1 value means that it should be inserted.
        final sources = new List<int>.filled(bLength, -1);
  
        var moved = false;
        var removeOffset = 0;
  
        // when both lists are small, we are using naive O(M*N) algorithm to
        // find removed children.
        if (aLength * bLength <= 16) {
          var lastTarget = 0;
  
  