anchor.diff:  
     static RenderNodeWrapper _getMounted(RenderCSS node) => _nodeMap[node];
   
  -  RenderNodeWrapper({ Object key }) : super(key: key);
  -
  +  RenderNodeWrapper({
  +    Object key,
  +    this.style,
  +    this.inlineStyle
  +  }) : super(key: key);
  +
  +  final Style style;
  +  final String inlineStyle;
  +
  +  RenderCSS _createNode();
     RenderNodeWrapper get _emptyNode;
  -
  -  RenderCSS _createNode();
   
     void _sync(UINode old, RenderCSSContainer host, RenderCSS insertBefore) {
       if (old == null) {
  
positive.code:     }
  
      _nodeMap[_root] = this;
      _syncNode(old);
    }
  
    void _syncNode(RenderNodeWrapper old);
  
    void _removeChild(UINode node) {
      assert(_root is RenderCSSContainer);
      _root.remove(node._root);
      super._removeChild(node);
    }
  
    void _remove() {
      assert(_root != null);
      _nodeMap.remove(_root);
      super._remove();
    }
  }
  
  final List<UINode> _emptyList = new List<UINode>();
  
  abstract class OneChildListRenderNodeWrapper extends RenderNodeWrapper {
  
    final List<UINode> children;
    final Style style;
    final String inlineStyle;
  
    OneChildListRenderNodeWrapper({
      Object key,
      List<UINode> children,
      this.style,
      this.inlineStyle
    }) : this.children = children == null ? _emptyList : children,
         super(key: key) {
  
      assert(!_debugHasDuplicateIds());
    }
  
    void _remove() {
      assert(children != null);
      for (var child in children) {
        assert(child != null);
        _removeChild(child);
      }
      super._remove();
    }
  
    bool _debugHasDuplicateIds() {
      var idSet = new HashSet<String>();
      for (var child in children) {
        assert(child != null);
        if (child.interchangeable)
          continue; // when these nodes are reordered, we just reassign the data
  
        if (!idSet.add(child._key)) {
          throw '''If multiple non-interchangeable nodes of the same type exist as children
                  of another node, they must have unique keys.
                  Duplicate: "${child._key}"''';
        }
      }
      return false;
    }
  
    void _syncNode(RenderNodeWrapper old) {
      OneChildListRenderNodeWrapper oldOneChildListRenderNodeWrapper = old as OneChildListRenderNodeWrapper;
  
      List<Style> styles = new List<Style>();
      if (style != null)
  
negative.code:       parent._root.markNeedsLayout();
      }
      _root.updateInlineStyle(inlineStyle);
    }
  
    void _removeChild(UINode node) {
      assert(_root is RenderCSSContainer);
      _root.remove(node._root);
      super._removeChild(node);
    }
  
    void _remove() {
      assert(_root != null);
      _nodeMap.remove(_root);
      super._remove();
    }
  }
  
  final List<UINode> _emptyList = new List<UINode>();
  
  abstract class OneChildListRenderNodeWrapper extends RenderNodeWrapper {
  
    final List<UINode> children;
  
    OneChildListRenderNodeWrapper({
      Object key,
      List<UINode> children,
      Style style,
      String inlineStyle
    }) : this.children = children == null ? _emptyList : children,
    super(
      key: key,
      style: style,
      inlineStyle: inlineStyle
    ) {
      assert(!_debugHasDuplicateIds());
    }
  
    void _remove() {
      assert(children != null);
      for (var child in children) {
        assert(child != null);
        _removeChild(child);
      }
      super._remove();
    }
  
    bool _debugHasDuplicateIds() {
      var idSet = new HashSet<String>();
      for (var child in children) {
        assert(child != null);
        if (child.interchangeable)
          continue; // when these nodes are reordered, we just reassign the data
  
        if (!idSet.add(child._key)) {
          throw '''If multiple non-interchangeable nodes of the same type exist as children
                  of another node, they must have unique keys.
                  Duplicate: "${child._key}"''';
        }
      }
      return false;
    }
  
    void _syncRenderNode(OneChildListRenderNodeWrapper old) {
      super._syncRenderNode(old);
  
      if (_root is! RenderCSSContainer)
        return;
  
      var startIndex = 0;
      var endIndex = children.length;
  
      var oldChildren = old.children;
      var oldStartIndex = 0;
      var oldEndIndex = oldChildren.length;
  
  