anchor.diff:                  while next
                   finally
                      (loop for v across buckets
  +                         ;; reducing the max. number of buckets to check
  +                         ;; depending on the max_rank <= lg(size) approximation
  +                         ;; makes it actually slower, so leave it for now.
  +                         ;for idx from (ceiling (log size 2)) downto 0
                            when v
                              do (setf tree (link v tree))
                            finally
  
positive.code: 
  (defclass rank-pairing-heap ()
    ((size :initform 0 :initarg :size
           :type (integer 0 *))
     (root :initform nil :initarg :roots
           :type (or null node))))
  
  
negative.code: (defun extract-min (heap)
    (declare (type rank-pairing-heap heap))
    (let ((root (slot-value heap 'root))
          (size (slot-value heap 'size))
          (buckets (make-array #.(ceiling (log most-positive-fixnum (/ (1+ (sqrt 5)) 2)))
                               ;; approx of max. required buckets
                               :element-type '(or null node)
                               :initial-element nil)))
      (declare (dynamic-extent buckets)
               (optimize (speed 3) (space 0))
               (type (integer 1 #.most-positive-fixnum) size))
      (if (zerop (setf (slot-value heap 'size) (1- size)))
          (setf (slot-value heap 'root) nil)
          (let (tree)
            (loop for i = (node-lchild root) then next
  