var path = [Weak(root)]

            path.append(Weak(node))

        var path = [Weak(root)]

            path.append(Weak(child))

    internal private(set) var root: Weak<Node>

    internal private(set) var path: [Weak<Node>]

        self.root = Weak(root)

        self.root = Weak(root)

    internal init(path: [Weak<Node>], slots: [Int]) {

        path.append(Weak(node))

            path.append(Weak(node))

    weak var value: T?

    init(_ value: T) {

            precondition(index.root.value === self.root)

            let node = index.path.last!.value!

        index.expectValid(index.path[0].value === root)

        guard var last = index.path.last?.value else { index.invalid() }

            guard let node = index.path[i].value else { index.invalid() }

        var node = node ?? path.last!.value!.children[slots.last!]

        guard let n = path.removeLast().value else { invalid() }

            guard let p = path.last!.value else { invalid() }

        guard root.value != nil else { invalid() }

        guard let node = self.path.last?.value else { invalid() }

                while slots.count > 0 && slots.last! == path.last!.value!.elements.count {

        expectValid(root.value != nil)

            descend(.Backward, node: root.value!)

        guard let node = self.path.last!.value else { invalid() }

    guard let ar = a.root.value, br = b.root.value where ar === br else { return false }

    guard let ar = a.root.value, br = b.root.value where ar === br else { return false }

        guard a.path[i].value === b.path[i].value else { return false }

        guard a.path[i].value === b.path[i].value else { return false }

        self.value = value