anchor.diff:  
   (in-package :hyperluminal-mem-tree)
   
  -(deftype b+node-size () '(integer 0 #.(ash most-positive-fixnum -1)))
  +(deftype b+node-size ()
  +  #||#   #-(and) '(integer 0 #.(ash most-positive-fixnum -1))
  +         #+(and) '(unsigned-byte 24))
   
   
   (deftype b+node () 'simple-vector)
  +(deftype b+leaf () 'b+node)
   
  -(declaim (inline b+node-ref b+node-lo b+node-hi
  -                 (setf b+node-ref) (setf b+node-lo) (setf b+node-hi)))
  +(declaim (inline b+node-ref b+node-tag b+node-lo b+node-hi
  +                 (setf b+node-ref) (setf b+node-tag) (setf b+node-lo) (setf b+node-hi)))
   
   (defun b+node-ref (node index)
     (declare (type b+node node)
  
positive.code: 
  
  (defun test-b+node ()
    (test-b+node-args :node #(2 2)
                      :min-key 0 :max-key 0
                      :expected-results #(nil))
  
    (test-b+node-args :node #(2 3 a)
                      :min-key 0 :max-key 1
                      :expected-results #(a a))
  
    (test-b+node-args :node #(2 5 a 10 b)
                      :min-key 8 :max-key 11
                      :expected-results #(a a b b))
  
    (test-b+node-args :node #(2 13 a 10 b 12 c 14 d 16 e 18 f)
                      :min-key 8 :max-key 19
                      :expected-results #(a a b b c c d d e e f f)))
  
  
negative.code:   (let ((lo (b+node-lo node))
          (hi (b+node-hi node)))
      (cond
        ((< lo hi)
         (loop
            ;; lo, mid and hi point to keys and must always be even,
            ;; because odd positions contain children
            :do
            (let* ((mid  (the b+node-size (logand -2 (ash (+ lo hi) -1))))
                   (kmid (the fixnum (b+node-ref node mid))))
              (cond
                ((fixnum< key kmid) (setf hi mid))
                ((fixnum> key kmid) (setf lo mid))
                (t (return-from b+node-find (b+node-ref node (1+ mid))))))
            :while (< (+ lo 2) hi))
         (b+node-ref node (if (fixnum< key (b+node-ref node lo))
                              (1- lo)
                              (1+ lo))))
        ((= lo hi) (b+node-ref node (1- lo))) ;; no keys, only one child
        ((> lo hi) nil))))
        
  
  (defun b+leaf-find (node key)
    (declare (type b+node node)
             (type fixnum key))
    (let ((lo (b+node-lo node))
          (hi (b+node-hi node)))
      ;; (>= lo hi) means no keys, and leaves cannot have children,
      ;; much less a lone child without keys
      (when (< lo hi) 
        (loop
           ;; lo, mid and hi point to keys and must always be even,
           ;; because odd positions contain values
           :do
           (let* ((mid  (the b+node-size (logand -2 (ash (+ lo hi) -1))))
                  (kmid (the fixnum (b+node-ref node mid))))
             (cond
               ((fixnum< key kmid) (setf hi mid))
               ((fixnum> key kmid) (setf lo mid))
               (t (return-from b+leaf-find (values (b+node-ref node (1+ mid)) t)))))
           :while (< (+ lo 2) hi))
        (when (fixnum= key (b+node-ref node lo))
          (return-from b+leaf-find (values (b+node-ref node (1+ lo)) t)))))
    (values nil nil))
  
                 
              
  (defun test-b+node-args (&key node min-key max-key expected-results)
  