                     m2 (apply dissoc m ks1)
                     n1size partition-size
                     n2size (- partition-size (rem size 2))
+                    n1 (->B+TreeLeafNode b n1size m1)
                     n2 (->B+TreeLeafNode b n2size m2)
-                    n1 (->B+TreeLeafNode b n1size m1)
-                    nleafnbs (update-leaf-neighbours n n1 n2)]
-                (println "NLEAFNBS" nleafnbs)
+                    nleafnbs (update-leaf-neighbours n1 n2)]
                 [n1 (last ks1) n2 nleafnbs]))
 
-            (ins [{:keys [b m size] :as n} k v]
+            (ins [k v]
               (let [nsize (if (contains? m k) size (inc size))
                     nm (assoc m k v)]
                 (->B+TreeLeafNode b nsize nm)))]
 
-      (let [nn (ins this k v)]
+      (let [nn (ins k v)]
         (if (>= (-> nn :size) b)
           (split nn)
-          [nn nil nil (insert-leaf-neighbours this nn)]))))
+          [nn nil nil (insert-leaf-neighbours nn)]))))
 
   B+TreeLookupable
 

    [k (get m k)])

  (lookup-range [this k klen leaf-neighbours]
    (println "RANGE LOOKUP" k klen (keys m))
    (when (<= (cmp-keys (-> m keys first) k) 0)
      (let [matching-keys (->> (keys m)
                               (filter #(= (cmp-keys % k) 0)))]
        (println "  MK" (keys m) matching-keys)
        [k (concat (-> (select-keys m matching-keys)
                       vals
                       vec)
                   (when-let [next (get leaf-neighbours this)]
                     (second (lookup-range next k klen leaf-neighbours))))])))

  B+TreeLeafNodeIterable


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

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