           s  (into (btset) xss)]
       (when-not (= (vec s) xs)
         (println xss))))
-  (println "Checked"))
+  (println "Checked")
+  :ok)
 
 ;; (test-rand)
 
 ;; perf
 
-(def test-matrix [:target  { "sorted-set" (sorted-set)
+(def test-matrix [:target  { ;; "sorted-set" (sorted-set)
                              "btset"      (btset)}
-                  :size    [100 500 1000 2000 5000 10000 20000 50000]
-;;                   :size    [100 500]
-                  :method  { ;; "conj"    (fn [opts] (into (:target opts) (:range opts)))
-                             ;; "lookup"  (fn [opts] (contains? (:set opts) (rand-int (:size opts))))
-                             "iterate" (fn [opts] (doseq [x (:set opts)] (+ 1 x))) }])
+;;                   :size    [100 500 1000 2000 5000 10000 20000 50000]
+                  :size    [100 500 20000]
+                  :method  { "conj"    (fn [opts] (into (:target opts) (:range opts)))
+                             "lookup"  (fn [opts] (contains? (:set opts) (rand-int (:size opts))))
+                             "iterate" (fn [opts] (doseq [x (:set opts)] (+ 1 x)))
+                            }])
 
 (defn test-setup [opts]
   (let [range (shuffle (range (:size opts)))]

      (-write writer "\n")
      (dump (aget (.-pointers node) i) writer (str "  " offset)))))

(extend-type BTSet
  IPrintWithWriter
  (-pr-writer [o writer _]
    (dump (.-root o) writer "")))


(defn test-rand []
  (dotimes [i 100]

        (pos? cmp) (recur arr l (dec m) k)
        :else m))
    l))
    
(defn ^number lookup-leaf [^array arr key]
  (binary-search arr 0 (- (alength arr) 1) key))

(defn ^number lookup-node [^array arr key]
  (binary-search arr 0 (- (alength arr) 2) key))

(defn ^number -seek [set key]
  (loop [node  (.-root set)
         path  empty-path
         level (.-shift set)]
    (if (== 0 level)
      (path-set path level (lookup-leaf (.-keys node) key))
      (let [idx (lookup-node (.-keys node) key)]
        (recur (aget (.-pointers node) idx)
               (path-set path level idx)
               (- level level-shift))))))

(defn ^number seek [set key]
  (binding [*cmp* (.-comparator set)]
    (-seek set key)))

;; Array operations

(defn ^array cut-n-splice [^array  arr
                           ^number cut-from
                           ^number cut-to
                           ^number splice-from
