     [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)
+    (when (>= (cmp-keys k (-> m keys first)) 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))))])))
+        ;;; TODO: we don't really need k in this case, as it is only needed for when we get
+        ;;;   invoked by insert. as this never happens for lookup-range, we could get rid of
+        ;;;   k (i.e. result in 2-tuple vector form). however, currently lookup* (below) relies
+        ;;;   on the format to be a 2-tuple, so we leave it like that for the moment:
+        [k (lazy-seq
+            (concat (-> (select-keys m matching-keys)
+                        vals
+                        vec)
+                    (when-let [next (-> (get leaf-neighbours this) :next)]
+                      (second (lookup-range next k klen leaf-neighbours)))))])))
 
   B+TreeLeafNodeIterable
 

                    m2 (apply dissoc m ks1)
                    n1size partition-size
                    n2size (- partition-size (rem size 2))
                    n2 (->B+TreeLeafNode b n2size m2)
                    n1 (->B+TreeLeafNode b n1size m1)
                    nleafnbs (update-leaf-neighbours n n1 n2)]
                (println "NLEAFNBS" nleafnbs)
                [n1 (last ks1) n2 nleafnbs]))

            (ins [{:keys [b m size] :as n} 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)]
        (if (>= (-> nn :size) b)
          (split nn)
          [nn nil nil (insert-leaf-neighbours this nn)]))))

  B+TreeLookupable


                    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)
