         let z: Node
         do {
             precondition(i._safe, "Cannot remove an index that is out of range.")
-            precondition(i.treeID == uuid, "Index to remove is either invalidated or does not belong to this tree.")
-
-            let refind = ensureUnique() // call this before creating additional references to nodes
-
-            var node = i.node! // get the node
+
+            ensureUnique() // call this before creating additional references to nodes
+
+            let node = i.node! // get the node
             
-            // the index was in the previous tree, find it in this one
-            if refind {
+            /*
+            If indexes change to remain valid after modification, indexes from previous trees will need to be located in this one using similar code to this.
+            Note that if the tree has since changed, simply retracing the same path (as here) will not work.
+            // the index was in a previous tree, find it in this one
+            if !root.contains(node) {
                 // make a path of left (true) / right turns from the root
                 var path = ContiguousArray<Bool>()
                 // the other tree has a different sentinel

                }
                assert(node.key == old.key)
            }
            loopSentinel()
            uuid = _nextTreeID()
            z = node
        }



    /// - Complexity: O(1)
    public var startIndex: Index {
        guard firstNode != sentinel else { assert(count == 0 && root == sentinel); return Index(empty: ()) }
        assert(firstNode.predecessor() == nil)
        return Index(node: firstNode)
    }

    /// - Complexity: O(1)
    public var endIndex: Index {
        guard lastNode != sentinel else { assert(count == 0 && root == sentinel); return Index(empty: ()) }
        assert(lastNode.successor() == nil)
        return Index(end: lastNode)
    }

    /// - Complexity: O(1)
    public subscript(index: Index) -> Key {
        guard case .Node(let u) = index.kind else { preconditionFailure("Cannot subscript an out-of-bounds index.") }
        return u.value.key
    }
