anchor.diff:         ;; Interpreted function. Second entry in the constant pool.
          (memref-t address 7)))))
   
  +(defun function-lambda-expression (function)
  +  (check-type function function)
  +  (let* ((address (logand (lisp-object-address function) -16))
  +         (info (memref-unsigned-byte-64 address 0)))
  +    (ecase (logand info #xFF)
  +      (#.+function-type-function+ ;; Regular function. First entry in the constant pool.
  +       (values nil nil (* (logand (ash info -16) #xFFFF) 2)))
  +      (#.+function-type-closure+ ;; Closure.
  +       (values nil t (function-name (memref-t address 4))))
  +      (#.+function-type-interpreted-function+
  +       (values (memref-t address 5) (memref-t address 6) (memref-t address 7))))))
  +
  +(defun compiled-function-p (object)
  +  (when (functionp object)
  +    (let* ((address (logand (lisp-object-address object) -16))
  +           (info (memref-unsigned-byte-64 address 0)))
  +      (not (eql (logand info #xFF) +function-type-interpreted-function+)))))
  +
   (defvar *gensym-counter* 0)
   (defun gensym (&optional (thing "G"))
     (make-symbol (format nil "~A~D" thing (prog1 *gensym-counter* (incf *gensym-counter*)))))
  
positive.code:                                    (declare (ignore r))
                                     (error 'undefined-function :name symbol))
          (get symbol '%macro-function) value))
  
  ;;; Calls to these functions are generated by the compiler to
  ;;; signal errors.
  
negative.code:           ((:constant) +symbol-mode-constant+)
            ((:symbol-macro) +symbol-mode-symbol-macro+)))
    value)
  
  (setf (symbol-mode 'nil) :constant)
  
  (defun variable-information (symbol)
    (symbol-mode symbol))
  
  ;;; The compiler can only handle (apply function arg-list).
  (defun apply (function arg &rest more-args)
  