              time)
       t2 (-> (t/insert t1 [:b "y" 3] "____")
              time)]
-  #_(clojure.pprint/pprint t)
+  #_(clojure.pprint/pprint t2)
   [(time (t/lookup-range t1 [:b "y"]))
    (time (t/lookup-range t2 [:b "y"]))])
-
-
-
-#_(defrecord B+TreeNode [b size children leaf?]
-
-  TreeModify
-
-  (insert [this k v]
-    (letfn [(split [children size]
-              (println "SPLIT1" (keys children) (type children))
-              (let [partition-size (-> size (/ 2) Math/ceil int)
-                    [ks1 ks2] (partition-all partition-size (keys children))
-                    cs1 (apply dissoc children ks2)  ;; cannot use select-keys here, as that removes sorted-map properties
-                    cs2 (apply dissoc children ks1)]
-                (println "SPLIT2" ks1 ks2 (type cs1) (type cs2))
-                (let [res [{:c cs1
-                            :s partition-size
-                            :k (last ks1)}
-                           {:c cs2
-                            :s (- partition-size (rem size 2))
-                            :k (last ks2)}]]
-                  (println "SPLIT3" res)
-                  res)))
-
-            (ins [children size k v]
-              (println "INS" size k v children)
-              (let [children (assoc children k v)
-                    size (inc size)]
-                (if (< size b)
-                  [{:c children :s size :k k}]
-                  (split children size))))
-
-            (add* [{:keys [b children size leaf?] :as this} k v root? i]
-              #_(println "ADD*" k v root? leaf?)
-              (if (<= i 5)
-                (cond
-                  leaf? (let [_ (println "LEAF1" k v)
-                              [m1 m2] (ins children size k v)]
-                          (println "LEAF2" m1 m2)
-                          [{:n (->B+TreeNode b (:s m1) (:c m1) true)
-                            :k (:k m1)}
-                           (when-not (nil? m2)
-                             {:n (->B+TreeNode b (:s m2) (:c m2) true)
-                              :k (:k m2)})])
-                  #_root? #_(let [_ (println "ROOT1" k v)
-                              child (get children k)
-                              [b1 sk b2] (add* child k v false (inc i))]
-                          (println "ROOT2" b1 sk b2)
-                          [(if (nil? b2)
-                             b1
-                             (->B+TreeNode b 1 (rm/range-map :find-ceiling b2 sk b1) false))])
-                  true (let [_ (println "TRUE1" k v)
-                             child (get children k)
-                             orig-k (-> child meta :sample.rangemap/key)
-                             [b1 b2] (add* child k v false (inc i))]
-                         (println "TRUE2" b1 b2 orig-k)
-                         (if (nil? b2)
-                           [{:n (->B+TreeNode b size (assoc children orig-k (:n b1)) leaf?)
-                             :k orig-k}]
-                           (let [children   (-> (dissoc children k)
-                                                (assoc (:k b1) (:n b1)))
-                                 [m1 m2] (ins children size (:k b2) (:n b2))]
-                             (println "TRUE3" m1 m2)
-                             [{:n (->B+TreeNode b (:s m1) (:c m1) false)
-                               :k (:k m1)}
-                              (when-not (nil? m2)
-                                {:n (->B+TreeNode b (:s m2) (:c m2) false)
-                                 :k (:k m2)})]))))
-                (do (println "ABORT")
-                    [this])))]
-
-      (println "=== ADD* ===" k v)
-      (let [[b1 b2] (add* this k v true 0)]
-        (println "ADD*2" b1 b2)
-        (let [res (if (nil? b2)
-                    (:n b1)
-                    (->B+TreeNode b 1
-                                  (-> (rm/range-map :find-ceiling)
-                                      (assoc (:k b1) (:n b1) :sample.rangemap/fallback (:n b2)))
-                                  false))]
-          (println "ADD*3" res)
-          res))
-
-      (split (-> (rm/range-map :find-ceiling)
-                 (assoc 1 11 2 22 3 33 4 44 :sample.rangemap/fallback 55))
-             5)))
-
-  TreeSearch
-
-  (lookup [this k]
-    (when-let [child (get children k)]
-      (if (satisfies? TreeSearch child)
-        (lookup child k)
-        child))))
-
-
-#_(defn b+tree [b]
-  (->B+TreeNode b 0 (sorted-map) true))

(defn b+tree [b]
  (->B+Tree b (->B+TreeLeafNode b 0 (sorted-map)) {}))


#_(-> (b+tree 3)
    (t/insert [:a 5] 55)

  (if-not (nil? k)
    (assoc m k v)
    m))


(defprotocol B+TreeModifyable
