             (pow 2 (bit base level)))))
 
 (defn id->node
-  ([id] (id->node id nil (base)))
-  ([id element] (id->node id element (base)))
+  [id element] (id->node id element (base)))
   ([{:keys [digit site counter] :as id} element base]
    (let [length (count counter)
          bit-length (sum base (- length 1))]

     (recur (first (:children node)) (inc acc)))))

(defn node->id
  ([node] (node->id node (base)))
  ([node base]
   (let [length (depth node)]
     (loop [{:keys [children]
             {:keys [path site counter]} :triple} node

                              (nth site level)
                              (nth counter level)))
                (inc level))
         (node triples element)))))

(defn compare
  [id other base]
  (let [id-length        (count (:counter id))
        other-length     (count (:counter other))
        min-length       (min id-length other-length)
