   t/TreeModifyable
 
   (insert [this k v]
-    (letfn [#_(neighbour-map [root]
-                (let [nodes (iterate-leafnodes root)
-                      prevs (concat [nil] nodes)
-                      nexts (-> (rest nodes) (concat [nil]))]
-                  (->> (map (fn [node prev next]
-                              [node prev next])
-                            nodes prevs nexts)
-                       (reduce (fn [s [node prev next]]
-                                 (assoc s node {:prev prev
-                                                :next next}))
-                               {}))))]
-
-      (let [[n1 k n2 nlnbs] (insert root k v leaf-neighbours)
-            nroot (if (nil? n2)
-                    n1
-                    (->B+TreeInternalNode b 1 [k] [n1 n2]))]
-        (->B+Tree b nroot nlnbs))))
+    (let [[n1 k n2 nlnbs] (insert root k v leaf-neighbours)
+          nroot (if (nil? n2)
+                  n1
+                  (->B+TreeInternalNode b 1 [k] [n1 n2]))]
+      (->B+Tree b nroot nlnbs)))
 
   t/TreeLookupable
 

                    vs2             (concat vs2a vs2b)]
                [(->B+TreeInternalNode b (dec partition-size) ks1 vs1)
                 nk
                 (->B+TreeInternalNode b (- partition-size (rem size 2)) ks2 vs2)
                 leaf-neighbours]))

            (ins [{:keys [b ks vs size] :as n} k v]
              (if-not (= k ::inf)



#_(-> (b+tree 3)
    (t/insert [:a 5] 55)
    (t/insert [:a 9] 99)
    (t/insert [:a 3] 33)
    (t/insert [:a 4] 44)
    (t/insert [:a 2] 22)
    (t/insert [:a 1] 11)
    (t/lookup-range [:a 3]))

#_(let [kvs (take 100000 (repeatedly #(let [k (-> (rand-int 9000000)
                                                (+ 1000000))]
