     public func contains(key : T) -> Bool {
         do {
             let (node, _) : (TreeNode<T,U>, PageStatus) = try mediator.readPage(root)
-            return node.contains(mediator: mediator, key: key)
+            return node.contains(key: key, mediator: mediator)
         } catch {}
         return false
     }

    public func get(key : T) -> [U] {
        do {
            let (node, _) : (TreeNode<T,U>, PageStatus) = try mediator.readPage(root)
            return node.get(mediator: mediator, key: key)
        } catch {}
        print("*** No tree node found for root '\(root)'")
        return []

    }
    
    public func makeIterator() -> AnyIterator<(T,U)> {
        var pairs = [(T,U)]()
        do {
            var path = try TreePath.minPath(tree: self, mediator: mediator)
            return AnyIterator {
                repeat {
                    if pairs.count > 0 {
                        return pairs.remove(at: 0)
                    } else {
                        guard path.leaf != nil else { return nil }
                        pairs.append(contentsOf: path.leaf!.pairs)
                        _ = path.advanceLeaf()
                    }
                } while true
            }
        } catch let e {
            print("*** \(e)")
            return AnyIterator(pairs.makeIterator())
        }
    }
    
    public func walk(between: (T,T), onPairs: @noescape ([(T,U)]) throws -> ()) throws {
