anchor.diff:        SplayTreeNode<K, V> right = _root.right;
         _root = _root.left;
         // Splay to make sure that the new root has an empty right child.
  -      splay_(key);
  +      _splay(key);
         // Insert the original right child as the right child of the new
         // root.
         _root.right = right;
       }
  +    _modificationCount++;
       return value;
     }
   
     void operator []=(K key, V value) {
  -    if (isEmpty) {
  +    if (_root == null) {
         _count++;
         _root = new SplayTreeNode(key, value);
  +      _modificationCount++;
         return;
       }
       // Splay on the key to move the last node on the search path for
       // the key to the root of the tree.
  -    splay_(key);
  -    if (_root.key.compareTo(key) == 0) {
  +    int comp = _splay(key);
  +    if (comp == 0) {
         _root.value = value;
         return;
       }
  +    _addNewRoot(key, value, comp);
  +  }
  +
  +  /**
  +   * Adds a new root node with the given [key] or [value].
  +   *
  +   * The [comp] value is the result of comparing the existing root's key
  +   * with key.
  +   */
  +  void _addNewRoot(K key, V value, int comp) {
       SplayTreeNode<K, V> node = new SplayTreeNode(key, value);
       // assert(_count >= 0);
       _count++;
  -    if (key.compareTo(_root.key) > 0) {
  +    if (comp < 0) {
         node.left = _root;
         node.right = _root.right;
         _root.right = null;
  
positive.code: 
      _dummy.right = null;
      _dummy.left = null;
    }
  
    V operator [](K key) {
      if (!isEmpty) {
        splay_(key);
        if (_root.key.compareTo(key) == 0) return _root.value;
      }
      return null;
    }
  
    V remove(K key) {
      if (isEmpty) return null;
      splay_(key);
      if (_root.key.compareTo(key) != 0) return null;
      V value = _root.value;
  
      _count--;
  
negative.code:     }
      // Maybe implement a splay-method that can splay the minimum without
      // performing comparisons.
      _splay(node.key);
      return node.key;
    }
  
  