anchor.diff:  (defun get (key hamt)
     (declare #.*interface* (hamt hamt))
     (let ((root-entries (hamt-root-entries hamt))
  +        (new-root-entries (hamt-new-root-entries hamt))
           (root-bitlen  (hamt-root-bitlen hamt))
  +        (resize-threshold (hamt-resize-threshold hamt))
           (hash         (hamt-hash hamt)))
       (declare #.*fastest*)
       (let ((in (new-arc-stream key :hash hash)))
         (declare (dynamic-extent in))
         (loop WITH node = nil
               FOR arc   = (read-n-arc in root-bitlen) THEN (read-arc in)
  -            FOR entry = (aref root-entries arc) THEN (get-entry node arc)
  +            FOR entry = (aref (if (< arc resize-threshold)
  +                                  root-entries new-root-entries)
  +                              arc) THEN (get-entry node arc)
           DO
           (typecase entry
             (null     (return (values nil nil)))
  
positive.code:                                           (arc-stream-start in) (arc-stream-rehash-count in)
                                            (if node 
                                                (set-entry node arc (make-amt-node))
                                              (setf (aref root-entries arc) (make-amt-node)))
                                            hamt))))))))))
  
  (defsetf get (key hamt) (new-value)
    `(progn (set-impl ,key ,new-value ,hamt)  
  
negative.code:             (set-entry node a1 kv1)
              (set-entry node a2 kv2)))))))
  
  (defun resize-one (hamt)
    (declare (hamt hamt))
    (with-slots (root-entries hash root-bitlen new-root-entries resize-threshold) hamt
      (cond ((= resize-threshold #1=(length root-entries)) ; TODO(?): eq new old
             (setf new-root-entries (make-array (ash #1# +PER-ARC-BIT-LENGTH+) :initial-element nil)))
            ((< resize-threshold #1#)
             (let ((e (aref root-entries resize-threshold))
                   (base resize-threshold))
               (typecase e
                 (amt-node (loop FOR arc FROM 0 BELOW +BITMAP-SIZE+ ;; TODO: each-entry
                                 FOR sub-e = (get-entry e arc)
                                 WHEN sub-e
                             DO
                             (setf (aref new-root-entries (+ (the positive-fixnum (ash arc root-bitlen)) base)) sub-e))
                           (free-entries (amt-node-entries e) *entries-pool*))
  
                 (key/value (let ((in (new-arc-stream (k/v-key e) :hash hash)))
                              (declare (dynamic-extent in))
                              (setf (aref new-root-entries (read-n-arc in (+ root-bitlen +PER-ARC-BIT-LENGTH+))) e)))))
             (setf (aref root-entries resize-threshold) nil)
             (when (zerop resize-threshold)
               (setf root-entries new-root-entries
                     resize-threshold (ash (length new-root-entries) +PER-ARC-BIT-LENGTH+))
               (incf root-bitlen +PER-ARC-BIT-LENGTH+)))
            )))
  
  (defun set-impl (key value hamt)
    (declare #.*interface* (hamt hamt))
    (with-slots (root-entries new-root-entries root-bitlen test hash entry-count resize-threshold) hamt
      (declare #.*fastest*)
      (let ((in (new-arc-stream key :hash hash)))
        (declare (dynamic-extent in))
        (loop WITH node = nil
              FOR arc   = (read-n-arc in root-bitlen) THEN (read-arc in)
              FOR entry = (aref #1=(if (< arc resize-threshold)
                                    root-entries new-root-entries)
                                arc) THEN (get-entry node arc)
          DO
          (typecase entry
            (null (incf entry-count)
                  (return (prog1 (if node
                                     (set-entry node arc (make-key/value key value))
                                   (setf (aref #1# arc) (make-key/value key value)))
                            (decf resize-threshold)
                            (resize-one hamt))))
            (amt-node  (setf node entry))
            (key/value 
             (return (if (funcall test key (k/v-key entry))
  