anchor.diff:    "Remove layers of closures and funcallable-instances from FUNCTION."
     (check-type function function)
     (let ((fundamental-fn function))
  -    (when (sys.int::funcallable-std-instance-p fundamental-fn)
  -      (setf fundamental-fn (sys.int::funcallable-std-instance-function fundamental-fn)))
  -    (when (sys.int::funcallable-std-instance-p fundamental-fn)
  +    (when (sys.int::funcallable-instance-p fundamental-fn)
  +      (setf fundamental-fn (sys.int::funcallable-instance-function fundamental-fn)))
  +    (when (sys.int::funcallable-instance-p fundamental-fn)
         ;; Bail out if there are multiple levels to funcallable-instances.
         (error "~S contains a nested funcallable-instance ~S." function fundamental-fn))
       (when (sys.int::closure-p fundamental-fn)
  
positive.code:                              (let ((slot (truncate (+ (ea-disp operand) 1) 8)))
                                 (if (ea-index operand)
                                     (push (format nil "slot ~D + ~S * ~S" slot (ea-index operand) (ea-scale operand)) annotations)
                                     (push (format nil "slot ~D" slot) annotations))
                                 (when (eql (ea-segment operand) :gs)
                                   (let ((thread-slot (slot-to-thread-slot-name slot)))
                                     (when thread-slot
                                       (push thread-slot annotations))))))
                             (when (and (not (ea-index operand))
                                        (eql (ea-disp operand) -3))
                               (push "car" annotations))
  
negative.code:       context))
  
  (defun slot-to-thread-slot-name (slot)
    (let* ((thread-struct (sys.int::get-structure-type 'mezzano.supervisor:thread))
           (thread-slots (sys.int::structure-definition-slots thread-struct)))
      (dolist (slot-def thread-slots)
        (cond ((sys.int::structure-slot-definition-fixed-vector slot-def)
               (cond ((eql (sys.int::structure-slot-definition-ref-fn slot-def) 'sys.int::%object-ref-t)
                      (when (and (zerop (rem slot 8))
                                 (<= (sys.int::structure-slot-definition-index slot-def)
                                     (/ slot 8)
                                     (+ (sys.int::structure-slot-definition-index slot-def)
                                        (sys.int::structure-slot-definition-fixed-vector slot-def)
                                        -1)))
                        (return
                          (format nil "thread-~(~A~)+~D" (sys.int::structure-slot-definition-name slot-def)
                                  (- (truncate slot 8)
                                     (sys.int::structure-slot-definition-index slot-def))))))
                     (t
                      (when (and (zerop (rem slot (mezzano.runtime::accessor-element-scale
                                                   (sys.int::structure-slot-definition-ref-fn slot-def))))
                                 (<= (sys.int::structure-slot-definition-index slot-def)
                                     slot
                                     (+ (sys.int::structure-slot-definition-index slot-def)
                                        (* (sys.int::structure-slot-definition-fixed-vector slot-def)
                                           (mezzano.runtime::accessor-element-scale
                                            (sys.int::structure-slot-definition-ref-fn slot-def)))
                                        -1)))
                        (return
                          (format nil "thread-~(~A~)+~D" (sys.int::structure-slot-definition-name slot-def)
                                  (truncate (- slot (sys.int::structure-slot-definition-index slot-def))
                                            (mezzano.runtime::accessor-element-scale
                                             (sys.int::structure-slot-definition-ref-fn slot-def)))))))))
              (t
               (when (if (eql (sys.int::structure-slot-definition-ref-fn slot-def) 'sys.int::%object-ref-t)
                         (= (sys.int::structure-slot-definition-index slot-def) (/ slot 8))
                         (eql (sys.int::structure-slot-definition-index slot-def) slot))
                 (return
                   (format nil "thread-~(~A~)" (sys.int::structure-slot-definition-name slot-def)))))))))
  
  (defun type-tag-to-name (tag)
    (when (zerop (ldb (byte 2 0) tag))
  